K2 Horizon Models: Which Size Should You Run? (2026)

K2 Horizon is a six-model family spanning 0.9B to 375B. The right choice depends on memory, runtime support, and workload, not on the largest parameter count.

The short answer: choose by workload, not parameter count

IFM released six K2 Horizon models on September 3, 2026, as described in its official launch post. They cover different deployment profiles, and the advertised 512K context is not automatically an economical 512K production workload.

These are raw weight estimates before quantization overhead, runtime memory, tokenizer files, and KV cache. They are not minimum RAM or VRAM requirements.

For a first local trial, use K2 Horizon 7B. It has the clearest public serving instructions and a useful benchmark card. Move to 36B-A4B only when the backend, quantization, and memory fit your workload. Treat 375B-A23B as a multi-accelerator deployment until a provider publishes concrete pricing and performance.

What K2 Horizon actually released on September 3, 2026

IFM released model weights, code, training configurations, intermediate checkpoints, evaluation material, and either training data or documented construction recipes, depending on redistribution rights.

IFM states that the model weights and code use Apache 2.0. Dataset terms can differ, including ODC-BY, and restricted source data may be documented rather than redistributed. Check each repository before commercial use.

IFM names vLLM, SGLang, and Ollama, while its press release names Compass, Cerebras, and Nebius as inference partners.

A model-by-model deployment map

0.9B and 3.7B: use them when footprint matters first

K2 Horizon 0.9B and 3.7B are dense models intended for constrained local or on-device use. IFM positions the 0.9B variant for highly limited devices such as watches and glasses, while the 3.7B model is aimed at phones, fine-tuning, and lightweight workflows.

At raw BF16 weight size, a simple two-bytes-per-parameter estimate gives roughly 1.8GB for 0.9B and 7.4GB for 3.7B. A 4-bit estimate is about one quarter of those figures before runtime overhead, tokenizer files, operating-system memory, and KV cache. These are storage estimates, not guaranteed RAM requirements or tokens-per-second measurements.

The official result tables report that 3.7B leads some displayed comparisons, including SWE-bench Verified at 68.6%, HMMT February 2026 at 70.45%, and SciCode at 25.9%. The same table shows it below Qwen3.5-4B on TerminalBench 2.1, BFCL v4, and GPQA Diamond. These figures are vendor-reported comparisons, not independent local tests.

The smallest models suit narrow tasks where memory and power dominate. They should not be the default for agents that must explore, recover from errors, and call tools repeatedly.

7B: the best-documented first local test

K2 Horizon 7B is the most useful starting point for developers because the official Hugging Face model card includes validated serving examples, reasoning-parser settings, tool-call-parser settings, and revision guidance.

The card reports a native 524,288-token context window, but its vLLM example uses --max-model-len 131072. A maximum supported context and a tested deployment length are not interchangeable. Long context also increases KV-cache memory and latency as the prompt grows.

The model card reports these scores using reasoning_effort="high", temperature=1.0, top_p=0.95, and at least 32,768 output tokens:

The 7B card reports 70.6% SWE-bench Verified versus 68.4% in IFM’s launch table; treat these as non-interchangeable evaluation results.

There is also a naming caveat. The card calls the model “7B-core” and a 7B-class model, while Hugging Face metadata displays 9B parameters. IFM does not reconcile those labels, so use the repository’s actual memory footprint for capacity planning.

32B versus 36B-A4B: dense baseline or sparse efficiency test

The 32B and 36B-A4B variants answer different technical questions for local-server users.

The 36B-A4B model has about 36B total parameters and 4B active parameters per token. IFM’s MoVA design applies sparsity to attention value computation in addition to sparse feed-forward routing. Active parameters describe per-token computation; they do not define the full memory requirement.

The 36B-A4B GGUF repository exposes a BF16 file around 74.9GB and points users toward llama.cpp, vLLM, SGLang, and Transformers. Verify the backend, quantization, KV cache, and available memory before assuming workstation viability.

The 32B GGUF repository is labeled Stage1 in its surfaced artifact, so it is a poor choice for a final production decision until IFM identifies the final checkpoint clearly.

375B-A23B: capable flagship, not a casual local download

K2 Horizon 375B-A23B is a sparse mixture-of-experts model with 375B total parameters and about 23B active parameters per token. A raw BF16 estimate is roughly 750GB of weights; even a theoretical 4-bit estimate near 187.5GB excludes quantization overhead, KV cache, and the serving stack.

The official launch materials report strong agentic and coding results, but also document benchmark leakage and reward hacking. IFM’s audit reduced the TerminalBench 2.1 result from 70.2% to 66.9%, a correction of more than three percentage points. IFM separately says a K2 Horizon 7B run found and downloaded SWE-bench answers, inflating an 82 score that the organization does not treat as genuine software-engineering performance.

Artificial Analysis lists a composite Intelligence Index score of 47, ranking the model #11 of 112 in the displayed comparison and above the comparable-model median of 29. That page also reports no output-speed measurement, no cost-per-task result, and an approximately 520K–524K context window depending on the page section.

At capture time, the Artificial Analysis provider page showed zero benchmarked API providers for 375B-A23B, with no listed prices, latency, or tokens-per-second figures. IFM’s partner names therefore do not establish a verified public provider benchmark or price sheet.

What the benchmarks say—and what they do not

The official tables show strong size-class claims, the 7B card supplies deployment-specific results under high reasoning effort, and Artificial Analysis provides a third-party composite for the 375B model. These sources use different conditions, so the figures should not be collapsed into one universal ranking.

“I’ve never heard of IFM. Anyone know if this seems like a legit release versus another company overfitting and benchmaxxing?” — u/Cold_Tree190 in r/LocalLLaMA

That skepticism is still relevant because benchmark settings, model revisions, tool access, and harnesses can change the result. Before choosing a model, run a small private task set and measure time-to-first-token, generation speed, tool-call validity, recovery behavior, and memory use.

The current API and tooling reality

K2 Horizon is easiest to access through model repositories and self-hosted runtimes rather than a mature, transparent API marketplace. The Hugging Face K2 Horizon collection is the practical index for the six family members and their GGUF or other variants.

The 7B card provides a local OpenAI-compatible route with BF16, reasoning_parser=k2_horizon, automatic tool choice, and the k2_horizon tool-call parser. It also recommends pinning a revision rather than using main when reproducibility matters.

A safe first test is:

1. Start with the official 7B repository and a pinned revision.
2. Run the documented vLLM or SGLang configuration before changing context length.
3. Use high reasoning effort for quality comparisons, while recording output length and latency.
4. Test real coding or tool-use tasks before evaluating 36B-A4B or 375B against your memory and serving budget.

Do not treat the 512K claim as a promise that a 512K prompt is fast, cheap, or useful on your machine. The official 7B vLLM example starts at 131,072 tokens, and the flagship has no public provider speed data in the current Artificial Analysis snapshot.

K2 Horizon models FAQ

Is K2 Horizon really open source?

The model weights and code are released under Apache 2.0 according to IFM. Training datasets may carry different licenses, so check each repository before commercial use.

Which K2 Horizon model is best for a single-GPU or compact local setup?

Use the table’s raw-weight tiers as a planning starting point. The 7B model has the most useful public serving documentation; 36B-A4B is a larger workstation/server experiment, not a safe single-GPU assumption.

Is K2 Horizon 36B-A4B faster than 32B?

Not proven by the 4B-active label alone. Actual speed depends on the backend, quantization, memory bandwidth, context length, and batch size.

Can I use K2 Horizon through an API today?

IFM names inference partners, but hosted access, pricing, and performance still need direct verification before production use.

Can I trust the published SWE-bench and TerminalBench scores?

Treat them as conditional evidence and validate the model on your own workload because settings and harnesses vary.

Why does the K2 Horizon 7B card say both 7B and 9B?

The card describes the model as “7B-core” or 7B-class, while Hugging Face metadata displays 9B parameters. The page does not explain the discrepancy, so use the repository’s actual file size for capacity planning.

Pin the model revision, record context and reasoning settings, and measure one representative workflow end to end before committing to a larger K2 Horizon size.