Open-Weight LLM · Private & Custom AI
A.X-K1
A sparse 519B-parameter MoE model with 33B active parameters, designed for hybrid reasoning/fast-inference workflows in private, self-hosted deployments where cost-per-inference and reasoning depth are both controllable.
A.X K1 is a decoder-only transformer with Mixture-of-Experts architecture trained from scratch by SKT. It activates only 33B of 519B parameters per token, enabling strong multilingual (EN/KO/ZH/JA/ES) and code performance without dense-model compute overhead. For ops teams, this means you can run high-capacity reasoning locally—switching between deep-thinking and fast-response modes—while keeping data fully within your environment.
Model facts
Private deployment
Run A.X-K1 in your own environment
A.X K1 is immediately deployable via vLLM and SGLang on tensor-parallel multi-node GPU clusters (validated on 4-node TP-32 setups). You own the model weights (Apache 2.0), control the full inference pipeline, and data never touches external APIs. The trade-off: 519B parameters require significant GPU memory even with sparse activation; a production instance needs enterprise-scale infrastructure (8x–16x H100/A100 clusters estimated). Worth it if you need reasoning-grade capability without API dependencies.
Operational AI use cases
Intelligent Customer Support Escalation & Triage
Route support tickets by extracting intent and context from unstructured queries. Run A.X K1 in non-think mode for low-latency categorization (78.6–81% instruction-following), or switch to think mode for edge cases requiring multi-step reasoning. All conversations stay in-house; no data shipped to third-party APIs.
Code Review & Internal Documentation Automation
Audit pull requests and auto-generate internal runbooks using the model's 87–93% HumanEval+ performance and multilingual code tokenizer. Hybrid mode lets you generate quick first-pass summaries (non-think) or deep structural analysis (think) on demand. Data never leaves your VPC.
Financial/Compliance Document Processing & Q&A
Extract and answer questions over regulatory filings, contracts, and internal policies using 131k-token context. Think mode handles complex multi-clause reasoning; non-think mode flags routine queries fast. Self-hosted means audit logs, PII handling, and retention policies stay under your control.
Custom AI
As a base for custom AI
A.X K1 works well as a backbone for domain-specific AI products where you want to own the model, fine-tune on proprietary data, and control inference hardware. The hybrid think/non-think architecture is flexible enough to support custom decision trees: route simple queries to non-think (faster, cheaper) and complex ones to think (slower, better reasoning). You can quantize or distill it (contact SKT for lightweight versions); architectural simplicity (no novel tokenizers or gating tricks) makes it easier to integrate into your inference stack than closed-source reasoning models.
In the operating system
Where it fits
Sits at the core of a private AI operating system's **reasoning & knowledge layer**. Use it as the backbone LLM for multi-step workflows (agent loops, document Q&A, code analysis), optionally wrapped by routing logic (simpler queries → non-think; complex → think) to optimize latency and cost. The MoE sparsity makes it practical to cohost with operational agents on the same cluster without saturating all GPUs.
Data control & security
Self-hosting A.X K1 means all inference, context, and outputs remain in your datacenter—no network calls to external LLM services. This is an **architecture choice**: data control is inherent to running any model privately. You still own security hardening (model injection attacks, prompt manipulation, side-channel inference); the model itself carries no built-in security/compliance guarantees. Useful for regulated environments (finance, healthcare, legal) where data residency or audit trails are mandatory.
Hardware footprint
**Estimate (verify before commit):** With 519B parameters and 33B active: - **FP16/BF16:** ~1 TB total (dense equivalent); MoE sparsity saves compute but not VRAM on typical setups. Requires 8×80GB H100 minimum for inference-only. - **INT8 quantization:** ~500 GB (contact SKT for official quants). - **Inference cost:** ~2–3 GPU-days per million tokens on 8×H100 (sparse routing + multi-token prediction). Batch size 4–8 to keep latency reasonable on a 4-node cluster.
Integration
Wiring into ops stacks: vLLM/SGLang handle batching, token streaming, and multi-GPU orchestration out of the box. Custom code flag on HF suggests non-standard inference logic (likely for think/non-think routing)—review GitHub examples before production. For agents: integrate via OpenAI-compatible API wrappers (standard vLLM), or call the model directly in Python for tighter latency control. Expect ~2–4 weeks to instrument logging, error handling, and fallback routing in a real workflow.
When it's not the right fit
- —Your team has no GPU infrastructure or wants API-first simplicity. A.X K1 demands ownership of a large multi-GPU cluster; managed inference (Bedrock, Azure AI) is easier.
- —You need guaranteed low-latency at 99.9th percentile. Think mode introduces variable latency (multi-step reasoning); non-think is faster but trades reasoning depth.
- —Your domain is specialized but outside the 5 languages (EN/KO/ZH/JA/ES) or code. Evals show uneven performance; limited data on niche verticals.
- —Long-context reasoning in practice: evals (AA-LCR 36%, Humanity's Last Exam 8.6%) suggest think mode struggles with ultra-long documents. Reasonable for 10–50k tokens; risky above.
Alternatives to consider
DeepSeek-V3.1 (685B-A37B)
Larger MoE with stronger long-context (AA-LCR 53%), but less multilingual focus and heavier resource demand. Comparable license (permissive) but slower inference per-token.
Llama 3.3 70B (dense)
Smaller, denser, easier to run on 2–4 GPUs; faster inference than A.X K1's 8×H100 baseline. Trade: no think/non-think, lower reasoning ceiling, but faster to prototype on.
Mixture-of-Agents (GLM-4.6 357B-A32B)
Similar parameter efficiency, slightly lighter on VRAM. Less multilingual specialization; ops teams should benchmark on actual workloads before switching.
Related open models
FAQ
Can I actually run A.X K1 on-premises without renting cloud GPUs?
Yes—if you own or can provision an 8–16 GPU cluster (H100/A100). Many enterprises already have this for ML training. If not, cloud GPU rental (Lambda Labs, CoreWeave) is cheaper short-term than buying. The big win is data stays in your VPC and you avoid per-token API costs at scale.
Is A.X K1 commercially usable under Apache 2.0?
Yes, Apache 2.0 explicitly permits commercial use, modification, and distribution with minimal obligations (include license, state changes). You can build and sell a product on top of it. No royalties to SKT. (But contact them for lightweight/quantized versions if you want pre-optimized binaries.)
What's the real difference between think and non-think mode? Can I A/B test them?
Think mode generates explicit reasoning steps before the answer (higher quality, slower, higher token cost). Non-think is concise direct output (faster, lower cost, less robust on hard problems). You can run both modes on the same request and compare latency/cost. Ops teams often route: simple queries → non-think; edge cases/escalations → think.
What happens if I fine-tune A.X K1 on proprietary data?
Fully legal under Apache 2.0. The model + your fine-tuned weights stay private if you self-host. SKT provides no official fine-tuning guidance; you'll need to adapt standard LoRA/QLoRA to the MoE architecture (non-trivial). Recommend consulting the GitHub repo or reaching out to SKT before starting.
Build a Private AI System Around A.X K1
LLM.co helps you architect, deploy, and fine-tune A.X K1 (or similar open models) into proprietary AI workflows—no data leaving your environment, full operational control. From infrastructure setup to ops automation, we handle the stack. Let's talk about your next intelligent system.