Raon-1 nano

Raon-1 nano is an open-weight, 3.1B-parameter dense language model developed by KRAFTON AI and distributed under the Apache 2.0 license. While many lightweight models strip away advanced architectural features to prioritize raw parameter savings, Raon-1 nano takes a distinct approach: it pairs 1.5B core effective parameters with a dedicated 1.5B per-layer embedding table and an expansive native context window of 262,144 tokens. The model is specifically tuned for bilingual Korean and English conversation, complex instruction following, multi-turn context retention, and native tool calling, with internal reasoning (thinking mode) enabled out of the box.

For practitioners looking to deploy a local AI model with 3.1B parameters, Raon-1 nano targets a practical middle ground between ultra-compact edge models and resource-heavy 7B-8B architectures. By applying architectural lessons from larger mixture-of-experts pipelines into a distilled dense structure, KRAFTON designed this model to run on standard consumer hardware, including single low-tier GPUs, Apple silicon laptops, and mobile runtime environments using LiteRT-LM.

Raon-1 nano is built on a 24-layer hybrid dense architecture designed to overcome the memory bottlenecks typical of standard Transformer decoders at ultra-long context lengths. The model was originally derived from KRAFTON's Raon-1 mini preview (a 30B-A4B mixture-of-experts model) through MoE-to-Dense pruning and knowledge distillation, followed by 3T tokens of continued pre-training and supervised fine-tuning with on-policy distillation.

The internal layer structure splits attention into two distinct mechanisms:

• Raon Delta Attention (RDA): 18 of the 24 layers use a gated delta-rule linear attention mechanism with separate erase and write gates. RDA relies on a fixed-size recurrent state rather than an expanding Key-Value (KV) cache, preventing linear memory expansion during generation.
• Gated Multi-Head Latent Attention (MLA): The remaining 6 layers utilize gated MLA. Because full attention is restricted to a quarter of the total layers, the entire KV cache footprint drops to roughly 7 KiB per token in BF16, making full 262k token sequences viable on consumer-tier VRAM.
• Raon-mHC Connections: The model stabilizes gradient flow across its 4 residual streams using a compute-efficient variant of manifold-constrained hyper-connections.
• Per-Layer Embeddings: Alongside its 1,536 hidden dimension, each layer maintains a 256-dimensional embedding table across the 259,840-token vocabulary. After each layer passes through its SwiGLU MLP block, it applies this embedding to modulate feature outputs before propagating down the residual stream.
• NoPE (No Positional Encoding): The architecture omits conventional positional encodings (like RoPE or ALiBi) in favor of implicit position tracking handled directly by the delta attention recurrences and MLA projections.

Because the model checkpoint incorporates a shared input/output LM head and an integrated 55M Multi-Token Prediction (MTP) module, total weights on disk total 3.2B parameters, with 3.1B actively participating in standard forward inference passes.

Raon-1 nano focuses on local agentic tasks, bilingual document understanding, and interactive problem solving.

Unlike base instruction models that emit raw answers immediately, Raon-1 nano generates hidden chain-of-thought tokens prior to providing its final response. This reasoning phase makes the model substantially more resilient on step-by-step logic, code scaffolding, and contextual disambiguation tasks compared to standard sub-4B models that attempt to generate answers in a single unguided pass.

The model is post-trained for reliable JSON extraction and structured tool calling. In local setups, practitioners can bind the model to filesystem APIs, local Python interpreters, home automation endpoints, or desktop automation scripts. Because it reliably identifies when a tool execution is required versus when direct conversation is appropriate, it works effectively as a compact, self-contained controller for local agent frameworks.

Most open-weight 3B models prioritize English or Chinese datasets, leaving Korean comprehension compromised by poor tokenization efficiency and weak idiom handling. Raon-1 nano was trained natively across both Korean and English corpuses with a broad 259k-token vocabulary. It demonstrates near parity across both languages, translating, summarizing, and reasoning across bilingual documents without dropping context or degrading output syntax.

With native 262,144-token context support, Raon-1 nano handles whole codebases, multi-chapter technical PDFs, and lengthy chat transcripts without external chunking. Combined with the hybrid linear attention layout, the context window does not run into the prohibitive memory quadratic scaling that usually breaks 3B models on consumer cards when context expands beyond 32k tokens.

Deploying Raon-1 nano locally requires minimal compute compared to standard 7B-14B models. Because of its 1.5B core active weights and reduced KV cache overhead, it is exceptionally forgiving on system memory.

The table below outlines real-world hardware targets across different precision levels when allocating standard context (8k tokens) versus deep context windows (64k to 262k tokens).

For the majority of local setups running llama.cpp, Ollama, or LM Studio, Q4_K_M is the recommended quantization balance. At less than 2 GB on disk, it fully retains the model's core instruction-following and tool-calling capabilities while fitting comfortably into 6 GB or 8 GB consumer GPUs. For users relying on strict mathematical reasoning or sensitive translation tasks, Q6_K or Q8_0 provides marginally higher precision without introducing substantial memory penalties.

• Budget Desktops and Laptops (4 GB - 8 GB VRAM): An NVIDIA GeForce RTX 3050, RTX 4060 (8 GB), or AMD Radeon RX 7600 can offload 100% of the Q4_K_M or Q6_K weights into VRAM. You can run long-context inferences without risking system memory offloading.
• Mid-to-High-End Workstations (12 GB - 24 GB VRAM): Running on an RTX 3060 (12 GB), RTX 4070, or RTX 4090 will allow you to leverage the full 262,144 token context window in unquantized FP16 or high-precision Q8_0 without exceeding memory caps. The best GPU for Raon-1 nano high-throughput batching is an RTX 4070 Ti Super or RTX 4080 (16 GB), which provides enough bandwidth to saturate the model's architecture.
• Apple Silicon (M-Series): Apple devices handle Raon-1 nano natively via MLX or GGUF. A base M2, M3, or M4 Mac Mini or MacBook Air with 8 GB or 16 GB of unified memory runs this model smoothly alongside routine desktop applications.

Thanks to the model's hybrid RDA and MLA structure, Raon-1 nano performance is bound primarily by memory bandwidth during token generation:

• NVIDIA RTX 4090 (24 GB): Generates 140 to 190 tokens per second at Q4_K_M, with minimal latency slowdown as prompt lengths stretch past 32k tokens.
• NVIDIA RTX 4060 (8 GB Laptop/Desktop): Sustains approximately 65 to 90 tokens per second at Q4_K_M.
• Apple M3 / M4 (Unified Memory): Delivers roughly 70 to 110 tokens per second using native MLX 4-bit quantization.
• Modern x86 CPU Only (AVX-512): Yields between 18 and 30 tokens per second via llama.cpp CPU inference.

You can run Raon-1 nano locally across several runtimes depending on your workflow:

1. llama.cpp / Ollama: The easiest route for cross-platform local use. You can pull the official GGUF quantization files directly from the KRAFTON Hugging Face repository and import them into an Ollama Modelfile or run them directly via the llama-cli tool.
2. Transformers and vLLM: Use PyTorch with trust_remote_code=True to execute the hybrid attention custom layers on Linux systems with CUDA acceleration.
3. MLX: For macOS users looking to maximize unified memory bandwidth and battery efficiency.
4. LiteRT-LM: Best suited for embedded Android runtimes or low-power edge nodes requiring a 4-bit bundle with minimal latency and standard 4k context limits.

To understand where Raon-1 nano fits, compare it against the leading alternatives in the 3B parameter segment: Meta's Llama 3.2 3B and Qwen 2.5 3B.

Llama 3.2 3B is one of the most widely deployed edge models, featuring strong baseline English reasoning, low memory demands, and broad quantization ecosystem support. However, Llama 3.2 utilizes a traditional dense Transformer architecture limited to a 128k context window, and its performance degrades rapidly when processing Korean or low-resource non-Western languages.

Furthermore, Raon-1 nano includes default reasoning chains, giving it an edge in multi-step problem solving over Llama 3.2 3B base instruction runs. If your workflow requires deep Korean bilingual competence or native 262k token comprehension, Raon-1 nano is the superior alternative.

Qwen 2.5 3B is among the strongest general-purpose small language models available, showing exceptional coding and mathematics benchmark numbers. However, Qwen 2.5 uses standard full attention across all layers, which causes its KV cache to consume massive amounts of VRAM as context grows toward its maximum limit.

Raon-1 nano counters this with its 18 RDA linear attention layers, which maintain a flat memory state for recurrent sequence processing. While Qwen 2.5 3B edges out Raon-1 nano on raw multilingual coding breadth and general Chinese datasets, Raon-1 nano delivers lower long-context VRAM overhead, native Korean conversational fluency, and built-in thinking execution.