# Open Models Are Everywhere. But What Is an Open Stack?

> Source: <https://dev.to/rijultp/open-models-are-everywhere-but-what-is-an-open-stack-1pd3>
> Published: 2026-09-08 21:01:55+00:00

*Hello, I'm Rijul, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. [Star us](https://github.com/HexmosTech/LiveReview/) to help devs discover the project, give it a try, and share your feedback to help improve the product.*

You may have downloaded **open models**, or at least heard of them.

These are models whose weights are made available for others to download and run on their own machine or infrastructure.

Usually, when accessing a model, you might do something like:

```
Your app → API → Model
```

But with an open-weight model, you can download the model weights and run them yourself. So it becomes more like:

```
Your app → Your infrastructure → Model
```

Some examples of **open-weight models** are **Llama, Mistral, Gemma, and Qwen**.

Now let's talk about another thing which you may or may not have heard of.

It's called **Open Stack**.

The model you get doesn't just happen by itself.

There are various layers involved in creating the final model that you use.

For example, you can think about the **model development pipeline** like this:

```
Training data
     ↓
Training code / recipes
     ↓
Model
     ↓
Evaluation
     ↓
Inference
     ↓
Deployment
```

So when we talk about an **open stack**, it's more like getting the model along with information and tooling around how it was created and operated.

You might get information about:

When you get an open-weight model, you generally won't get this much information.

But **open stack isn't a standardized technical category**. It is better to think of openness as a spectrum across different parts of the model development pipeline.

For example, a company might release:

but **not** release:

So while the model itself is available, much of the process behind creating it remains closed.

Some examples of projects that take a much more open approach to the model development process are **OLMo by Ai2** and **BLOOM by BigScience**.

If you've never heard of **open stacks** before, take a look at some of these projects.

It's interesting to see not just the final model, but also the **training, data, evaluation, and tooling that went into creating it**.

Your team's attention is limited, and the deluge of AI-generated code is making it harder to keep production reliable and secure without slowing you down.

I'm building **LiveReview**, a blast-radius aware AI code review built for your business-critical systems.

Instead of presenting every diff with equal emphasis, **LiveReview scores each change by blast radius — how far its impact reaches through your call graph — so you can focus attention where it actually matters.**

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub: 

LiveReview is an AI code reviewer that scores every hunk of a diff by **blast radius**: how far a change reaches through your call graph, how much persistent state it touches, and how well-tested it is. A 3-line change to a shared auth check can outrank a 300-line UI tweak. Your team's attention goes to the highest-risk code first, not spread evenly across every diff.

*LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.*

| The exact math, not a black box | Visualize blast radius at a glance | Every factor that feeds the score | 
|---|---|---|

**Here's the goal:**

**Click below to try LiveReview with your codebase:**