Overview

K-EXAONE-2.0-750B-A37B is a frontier-scale multilingual language model developed by LGAI-EXAONE featuring 750 billion total parameters with 37 billion active parameters during inference. The model uses a Mixture-of-Experts architecture with 256 total experts and 8 activated experts per token, supports a context window of 262,144 tokens, and covers ten languages: Korean, English, Spanish, German, Japanese, Vietnamese, French, Italian, Polish, and Portuguese. Built through upcycling its predecessor and scaling both depth and width, the model incorporates dual-mode functionality with reasoning and non-reasoning modes, making it suitable for both high-accuracy tasks and latency-sensitive applications. It implements advanced attention mechanisms including global attention without positional embeddings, sliding window attention, and a Multi-Token Prediction layer for speculative decoding. The knowledge cutoff is 2025 Q2. You can serve it using SGLang or vLLM with custom forks that include K-EXAONE-specific optimizations, and it is released under the Apache 2.0 license for broad ecosystem deployment.

Best use cases

Long-context retrieval and document understanding. This model achieves exceptional performance on long-context benchmarks, scoring 94.4% on OpenAI-MRCR and 89.6% on Ko-LongBench. With 262,144 token context length and optimized attention mechanisms including sliding window and global attention patterns, it handles retrieval-augmented generation, long document summarization, and multi-turn conversation preservation that would fail on shorter-context models. The preserved reasoning capability across long sequences makes it ideal for document-intensive research and legal analysis workflows.

Agentic coding and autonomous task execution. The model demonstrates strong performance on agentic workflows, scoring 68.2% on SWE Bench Verified and 77.7% on Claw-Eval. Its design specifically targets reasoning and tool-use capabilities through difficulty-focused mid-training. For autonomous code generation, debugging, and multi-step tool orchestration, the dual-mode system lets you trade off latency against accuracy—reasoning mode provides careful analysis while non-reasoning mode returns faster responses for straightforward coding tasks.

Multilingual knowledge work and safety-critical applications. Covering ten languages with strong performance (MMMLU 86.6%, GlobalMMLU-Lite 86.6%), the model excels in multilingual knowledge retrieval and reasoning. The safety benchmarks are exceptional: 99.8% on KGC-Safety and 89.5% on ROK-Fortress. This combination makes it suitable for production deployments requiring both multilingual understanding and robust safety guardrails, particularly for international customer support, content moderation, and regulatory compliance tasks.

Agentic long-horizon reasoning with preserved context. The preserve_thinking=True option allows the model to track previous reasoning across conversation turns, essential for complex multi-step research, planning, and problem-solving. Combined with speculative decoding acceleration (3–5× speedup via MTP or DSpark), this enables agentic systems that maintain reasoning coherence while meeting latency requirements. Use this for automated research synthesis, hypothesis generation, and iterative refinement workflows.

Math and reasoning-heavy benchmarks. The model scores competitively on mathematical reasoning: 92.3% on AIME 2026 and 78.6% on IMO Answer. While not leading-edge on pure math, the reasoning-mode capability allows the model to show work and explore solution paths, making it valuable for educational tutoring systems, automated homework evaluation, and research problem verification where explainability matters alongside accuracy.

Limitations

Inference at scale requires substantial hardware. At 750B total parameters with 37B active, you need a minimum of 16 H200 GPUs (two 8-GPU nodes) for recommended deployment according to the provided SGLang and vLLM configurations. Single-GPU inference is not practical. Memory requirements are significant: the vLLM configuration uses --gpu-memory-utilization 0.9, meaning the model consumes approximately 90% of GPU memory on high-end hardware. This hardware barrier excludes most small teams and individual researchers.

Speculative decoding is not universally supported. While MTP and DSpark provide 3–5× speedup, DSpark is currently not supported in vLLM, and both speculative methods require specific inference engine forks. The official SGLang fork (https://github.com/lkm2835/sglang@add-k-exaone2) and vLLM fork (https://github.com/lkm2835/vllm@add-k-exaone2) are non-standard installations, creating dependency management complexity. Broader framework support is limited.

Known instability on NVIDIA B200 GPUs. The documentation explicitly warns against using B200 hardware due to model generation collapse issues. The workaround requires disabling sliding window attention KV caching (EXAONE_ENABLE_SWA_KV=0) and adding --disable-prefill-cuda-graph, which likely degrades performance. This makes B200 adoption unavailable until LG releases updated fixes.

Below-leading performance on pure reasoning benchmarks. On IMO Answer, the model scores 78.6% versus 89.8% for DeepSeek V4 Pro. On HMMT Feb 2026, it scores 78.4% versus 95.2% for the same competitor. On Terminal-Bench 2.1 (agentic coding), it scores 43.8% versus 64.0%. While competitive with Qwen and GLM, the model does not match the very largest proprietary systems for pure mathematical reasoning, and this gap persists even with reasoning mode enabled.

Reasoning mode adds latency by default. The model ships with enable_thinking=True by default, meaning all inference runs the reasoning pathway, adding computational overhead. Setting enable_thinking=False is required for latency-sensitive workloads, but many users may inadvertently deploy with reasoning enabled and observe unexpected latency increases.

Limited compatibility with mainstream inference frameworks. You cannot use this model with standard vLLM or SGLang releases; you must use custom forks. This creates maintenance burden and may introduce fragmentation if the forks fall out of sync with upstream development.

How it compares

K-EXAONE-236B-A23B: K-EXAONE 2.0 is the successor, with 750B total parameters versus 236B and significantly improved performance. The 750B model achieves 83.5% on MMLU-Pro versus 83.8% on the predecessor (negligible difference), but dominates on long-context retrieval (94.4% versus 52.3% on OpenAI-MRCR) and safety (99.8% versus 96.1% on KGC-Safety). Use K-EXAONE 2.0 if you need long-context understanding, safety-critical deployment, or the latest frontier capabilities. Use the 236B model if you are severely constrained on hardware and can accept lower long-context performance.

EXAONE-4.0-32B: EXAONE 4.0 at 32B parameters is vastly smaller and demands far less hardware—deployable on a single high-end GPU. It supports reasoning and non-reasoning modes like K-EXAONE 2.0. However, K-EXAONE 2.0 delivers frontier-class performance with 37B active parameters (versus 32B total) and a 262,144 token context versus EXAONE 4.0's unknown but likely shorter context. Use K-EXAONE 2.0 for applications requiring maximum accuracy, long context, and multilingual sophistication; use EXAONE 4.0-32B if hardware or latency are critical constraints and you can accept moderate performance reduction.

EXAONE-4.0-1.2B: This tiny 1.2B model is designed for edge deployment and mobile, with trivial hardware requirements. K-EXAONE 2.0 is incomparable in capability—it is a frontier model versus a consumer model. Use EXAONE-4.0-1.2B only when you must run inference on-device with minimal power and network constraints. For any server-side application with reasonable hardware budgets, K-EXAONE 2.0 provides vastly superior intelligence.

EXAONE-4.0-1.2B-GGUF: This is the quantized version of EXAONE-4.0-1.2B for llama.cpp compatibility. Same capability limits as the unquantized 1.2B model, with the same reasoning: use only for edge devices where K-EXAONE 2.0 is not deployable.

EXAONE-3.5-2.4B-Instruct: EXAONE 3.5 at 2.4B (smallest variant) is bilingual and instruction-tuned. K-EXAONE 2.0 operates at a completely different scale and capability tier. Use EXAONE 3.5 only for resource-constrained edge or cost-optimized inference where accuracy can be sacrificed. K-EXAONE 2.0 is the choice for frontier applications requiring multilingual sophistication, long-context reasoning, and production-grade safety.

Technical specifications

Architecture and parameters: Mixture-of-Experts (MoE) with 750 billion total parameters and 37 billion active parameters. The model uses 78 main layers (2 dense heading layers + 76 sparse MoE layers) plus 1 Multi-Token Prediction layer. It contains 1 shared expert, 256 total experts, and activates 8 experts per token. Expert dimension is 2,048.

Attention design: Complex attention pattern optimized for long context. The model includes 1 global attention layer without positional embeddings (NoPE), 1 sliding window attention layer with 4,096 token window, and 19 repeating blocks containing 3 sliding window attention layers (128-token windows each) plus 1 global attention layer per block. Total attention heads: 64 query heads with 8 key-value heads; head dimension is 128. This hybrid design balances long-range dependencies via global attention with efficient local context via sliding window.

Hidden and intermediate dimensions: Hidden dimension is 6,144; intermediate (feedforward) size is 18,432. Vocabulary size: 153,600 tokens.

Context and cutoff: Maximum context length of 262,144 tokens (~200k words). Knowledge cutoff is 2025 Q2.

Multilingual coverage: Supports ten languages—Korean, English, Spanish, German, Japanese, Vietnamese, French, Italian, Polish, and Portuguese.

Inference optimization: Two speculative decoding methods available. Multi-Token Prediction (MTP) and DSpark both provide 3–5× speedup. The model supports dual-mode inference: reasoning mode (default, enable_thinking=True) for high-accuracy tasks and non-reasoning mode (enable_thinking=False) for latency-critical workloads. Reasoning output can be preserved across turns with preserve_thinking=True for agentic workflows.

Frameworks and serving: Compatible with the Hugging Face Transformers library (requires custom fork from https://github.com/nuxlear/transformers@add-k-exaone2). Official serving integrations exist via custom forks of SGLang (https://github.com/lkm2835/sglang@add-k-exaone2) and vLLM (https://github.com/lkm2835/vllm@add-k-exaone2). Standard vLLM and SGLang releases do not support this model.

Hardware requirements: Recommended deployment uses 16 GPUs across 2 nodes of 8× H200 GPUs each. For low-latency serving, use tensor parallelism of 16 with single-node deployment on 8× H200. For high-throughput serving, use tensor parallelism of 8 with data parallelism of 2 across 2 nodes. GPU memory utilization targets 90% on high-end hardware.

Quantization and format: Provided in BF16 (bfloat16) precision. GGUF format available through llama.cpp support for EXAONE-4.0 models, but K-EXAONE 2.0 quantization support is not explicitly documented.

License: Apache 2.0, permitting commercial use, modification, and distribution with attribution.

Model inputs and outputs

Inputs

Text prompts: UTF-8 encoded strings in any of the ten supported languages (Korean, English, Spanish, German, Japanese, Vietnamese, French, Italian, Polish, Portuguese)
Chat format: OpenAI-compatible API with- messagesarray containing- role("user", "assistant", "system") and- contentfields
Generation parameters:- max_tokens(integer, up to model's output limit),- temperature(float, recommended 1.0 for best quality),- top_p(float, recommended 0.95)
Inference mode control:- enable_thinking(boolean, default True for reasoning mode),- preserve_thinking(boolean, default False; set to True for agentic workflows to maintain reasoning across turns)
Batch inference: Supported via tensor parallelism; max-running-requests varies by serving configuration (128 for low-latency, 192 for high-throughput)

Outputs

Text completion: UTF-8 encoded string response in the same language as input
Reasoning content(when- enable_thinking=True): Wrapped in thinking tags, providing step-by-step reasoning accessible via- reasoning_contentfield if- preserve_thinking=True
Token usage: Completion tokens, prompt tokens, and total tokens in API response
OpenAI-compatible format: Follows OpenAI Chat Completions API response schema with- choices[0].message.contentcontaining the main response

Getting started

```
from openai import OpenAI

Connect to K-EXAONE 2.0 served via SGLang or vLLM on localhost:8000

client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY",
)

Example 1: Reasoning mode for high-accuracy coding task

messages = [
{
"role": "user",
"content": "Implement fibonacci with python code.",
}
]
response = client.chat.completions.create(
model="LGAI-EXAONE/K-EXAONE-2.0-750B-A37B",
messages=messages,
max_tokens=32768,
temperature=1.0,
top_p=0.95,
extra_body={
"chat_template_kwargs": {
"enable_thinking": True, # Enable reasoning mode
"preserve_thinking": True, # Keep reasoning for follow-ups
}
},
)
print(response.choices[0].message.content)

Example 2: Non-reasoning mode for latency-sensitive tasks

messages = [
{
"role": "user",
"content": "Explain how useful you are.",
}
]
response = client.chat.completions.create(
model="LGAI-EXAONE/K-EXAONE-2.0-750B-A37B",
messages=messages,
max_tokens=1024,
temperature=1.0,
top_p=0.95,
extra_body={
"chat_template_kwargs": {
"enable_thinking": False, # Disable reasoning for speed
}
},
)
print(response.choices[0].message.content)
```
Before running this code, you must start an inference server. For SGLang on two H200 nodes:

```

Node 0 (head):

sglang serve \
--model-path LGAI-EXAONE/K-EXAONE-2.0-750B-A37B \
--served-model-name K-EXAONE-2.0-750B-A37B \
--tp 16 \
--dist-init-addr \
--nnodes 2 \
--node-rank 0 \
--host 0.0.0.0 \
--port 8000 \
--max-running-requests 128 \
--speculative-algo EAGLE \
--speculative-num-steps 4

Node 1:

sglang serve \
--model-path LGAI-EXAONE/K-EXAONE-2.0-750B-A37B \
--served-model-name K-EXAONE-2.0-750B-A37B \
--tp 16 \
--dist-init-addr \
--nnodes 2 \
--node-rank 1 \
--host 0.0.0.0 \
--port 8000 \
--speculative-algo EAGLE \
--speculative-num-steps 4
```
Install required dependencies:

uv venv source .venv/bin/activate uv pip install openai uv pip install git+https://github.com/lkm2835/sglang@add-k-exaone2 uv pip install git+https://github.com/nuxlear/transformers@add-k-exaone2

Frequently asked questions

Q: Can I use K-EXAONE 2.0 commercially?

A: Yes. The model is released under Apache 2.0 license, which permits commercial use, modification, and distribution with attribution. You may deploy it in production systems and offer services based on it without licensing fees.

Q: What hardware do I need to run this model?

A: Minimum 16 GPUs across 2 nodes (8× H200 per node for recommended configuration). Single-GPU inference is not practical. The model consumes approximately 90% of GPU memory on high-end hardware. Standard consumer GPUs are insufficient; you need enterprise-grade accelerators like NVIDIA H200 or comparable.

Q: How much faster is inference with speculative decoding?

A: Both MTP (Multi-Token Prediction) and DSpark provide approximately 3–5× speedup over standard decoding. This dramatically reduces latency for long-horizon agentic tasks, but DSpark is not currently supported in vLLM (only SGLang).

Q: Does this model outperform Qwen3.5 on all benchmarks?

A: No. Qwen3.5 leads on several benchmarks: MMLU-Pro (89.8% vs 83.5%), GPQA-Diamond (88.4% vs 82.2%), Humanity's Last Exam (28.7% vs 18.3%), and SWE Bench Verified (76.4% vs 68.2%). K-EXAONE 2.0 excels specifically on long-context retrieval (94.4% vs 93.0% on OpenAI-MRCR) and safety (99.8% vs 92.0% on KGC-Safety), making it the better choice for retrieval-augmented generation and safety-critical deployments.

Q: Can I fine-tune or quantize this model?

A: Fine-tuning and quantization are possible using the Transformers library with the custom fork (https://github.com/nuxlear/transformers@add-k-exaone2), but official guidance is not provided in the model card. Check the GitHub repository for community examples.

Q: What is the difference between reasoning mode and non-reasoning mode?

A: Reasoning mode (enable_thinking=True, the default) activates the model's step-by-step reasoning pathway, improving accuracy on complex tasks but adding latency. Non-reasoning mode (enable_thinking=False) returns direct responses without reasoning, reducing latency by skipping the internal reasoning computation. Use reasoning mode for high-accuracy tasks like math and coding; use non-reasoning for chatbots and real-time applications.

Q: Does this model work with standard vLLM or SGLang?

A: No. You must use custom forks: SGLang from https://github.com/lkm2835/sglang@add-k-exaone2 and vLLM from https://github.com/lkm2835/vllm@add-k-exaone2. Standard releases do not include K-EXAONE 2.0 optimizations. Additionally, DSpark speculative decoding is not yet supported in vLLM.

Q: Why does the model fail on NVIDIA B200 GPUs?

A: Generation collapse occurs due to model architecture issues with B200 hardware. The workaround is to disable sliding window attention KV caching (EXAONE_ENABLE_SWA_KV=0) and disable prefill CUDA graphs, but this reduces performance. LG plans to release fixes; until then, use H200 or other supported GPUs.

Newspaper

K-EXAONE 2.0 Brings 262K Context to Frontier AI