K2 Horizon: The Largest Fully Open Model Fleet Yet, 0.9B to 375B With Weights, Data, and Recipes

On September 3, 2026 the Institute of Foundation Models (IFM), the research lab incubated by Mohamed bin Zayed University of Artificial Intelligence (MBZUAI) in Abu Dhabi, released K2 Horizon: a fleet of six foundation models spanning 0.9 billion to 375 billion parameters. Unlike the open-weights releases that have dominated headlines, the entire K2 Horizon family ships under Apache 2.0 with model weights, code, training data, and methodologies. IFM calls it the largest fully open model launch in AI history. For engineering teams, it is the first time the prototype-on-a-watch-to-enterprise-flagship path comes with a complete, reproducible toolchain. Every model in the fleet shares one interface and one deployment path, so the decision is no longer about picking a single winner but about choosing where each workload should run.

1. Fully Open Is Not Open Weights

Most of the recent industry debate has been about open weights; K2 Horizon raises the bar by publishing not just weights but training data, training code, data recipes, and evaluations under Apache 2.0. Founder Eric Xing puts it plainly: open source is much more than open weights -- science works when others can see the data, follow the method, reproduce the result, and improve on it. For teams under compliance and audit pressure, that turns reproducibility into a contractual property instead of a vendor promise.

// The K2 Horizon fleet: six sizes, one shared architecture,
// vocabulary, and toolchain. Route by deployment target, then
// scale up without changing your workflow.
const FLEET = [
  { size: "0.9B", target: "watches, constrained devices" },
  { size: "3.7B", target: "phones, on-device apps" },
  { size: "7B", target: "phones, on-device apps" },
  { size: "32B", target: "local hosting, on-premise servers" },
  { size: "36B-A4B", target: "on-premise, cost-aware serving" },
  { size: "375B-A23B", target: "enterprise reasoning workloads" },
];

function pickModel(budget) {
  if (budget.memoryMb < 2048) return "k2-horizon-0.9b";
  if (budget.device === "phone") return "k2-horizon-7b";
  if (budget.onPrem) return "k2-horizon-32b";
  return "k2-horizon-375b-a23b";
}

2. Six Sizes, One Toolchain

The lineup is easy to map: 0.9B for watches and tightly constrained devices; 3.7B and 7B for phones and on-device apps; dense 32B and sparse 36B-A4B for local hosting and on-premise servers; and the 375B-A23B MoE flagship for demanding enterprise reasoning. All six share a core architecture, vocabulary (except the 0.9B), training methodology, interfaces, and deployment tooling -- so moving from prototype to production does not change your workflow. IFM's dynamic model routing directs each task to the most cost-effective model in the fleet. The routing layer is open too, which means you can inspect how a task gets classified before it is dispatched, then tune the thresholds to your own traffic mix.

# Serve the 7B model on a laptop-class box with vLLM. The whole
# fleet shares one deployment toolchain, so swapping to 32B is a
# one-line image change.
services:
  k2-7b:
    image: vllm/vllm-openai:latest
    command:
      - --model
      - ifm/k2-horizon-7b
      - --max-model-len
      - "32768"
    ports:
      - "8000:8000"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

3. Two Techniques Worth Borrowing

IFM published two underlying innovations: diffusion distillation, which generates blocks of tokens in parallel to speed decoding by roughly 3x without degrading response quality, and a mixture of value attention architecture that improves reasoning without adding compute. For self-hosted teams the first means a lower effective cost per token; the second is a reminder that better reasoning does not have to mean a bigger model or a bigger GPU bill.

// Every model exposes an OpenAI-compatible endpoint, so your
// existing client code works unchanged from 0.9B to 375B.
const request = {
  model: "k2-horizon-32b",
  messages: [
    {
      role: "user",
      content: "Explain why this query plan is slow and fix it.",
    },
  ],
  max_tokens: 1024,
  temperature: 0.2,
};

// curl localhost:8000/v1/chat/completions -d request.json

4. Prototype-to-Production Routing

A realistic path: validate prompts and tool calls with 7B on a laptop, serve internal workloads with 32B on-premise, and reserve the 375B flagship for the heaviest reasoning. The interface never changes. vLLM and SGLang support the fleet directly, and the OpenAI-compatible endpoint means your existing client code works unchanged. Teams that do not want to run hardware can call the API through inference partners including Compass, Cerebras, and Nebius today.

5. Reproduce, Don't Just Trust Benchmarks

IFM ships eval scripts and data recipes for every model: clone the repo, install dependencies, run the eval, and verify the coding, reasoning, and agentic scores on your own hardware. For teams tired of trusting vendor charts, this moves trust from marketing copy to executable evidence. It matters most for agentic workloads, where a local replay is far closer to your real load than any public leaderboard.

# Reproducibility is the point: weights, code, training data and
# recipes ship together. Verify claims on your own hardware.
git clone https://github.com/ifm/k2-horizon
cd k2-horizon && pip install -r requirements.txt
python eval/run_eval.py --model ifm/k2-horizon-32b   --tasks coding,reasoning,agentic
# Diffusion distillation speeds decoding roughly 3x by generating
# blocks of tokens in parallel; mixture of value attention cuts
# the compute needed for the same reasoning quality.

6. How to Adopt It

First, choose by deployment target rather than parameter count: 0.9B for a watch, 7B for a phone, 32B for an on-premise server, 375B for the enterprise flagship. Second, validate small and scale up, letting dynamic routing keep most requests on the cheapest adequate model. Third, remember that fully open does not mean governance-free: allowlists, audit, and budget caps still apply. Finally, treat reproducibility as a feature -- before you lock into any closed API, ask whether you could rebuild this workflow on your own rack if the vendor raised prices tomorrow. The presence of a fully open flagship changes the negotiation, not just the deployment: even teams that stay on managed APIs now hold a credible fallback that runs on their own hardware.

// Fully open does not mean zero governance. Keep the same policy
// layer you use for hosted models: allowlists, audit, and caps.
const modelPolicy = {
  allowlist: [
    "k2-horizon-7b",
    "k2-horizon-32b",
    "k2-horizon-375b-a23b",
  ],
  defaultRoute: "k2-horizon-32b",
  dataGuard: "all requests stay on-premise",
  audit: "log model, prompt hash, tokens, and latency",
  costCap: "infra_budget_only",
};