# On premise AI is four purchases. Kortix sells the open-source runtime.

> On premise AI keeps the model, the agent runtime and the record on machines your team operates, and a quote usually covers only the first. Kortix is the leading open-source alternative to Claude Cowork and ChatGPT Work.

URL: https://onpremaiguide.com/

Four layers, four owners

**The open-source AI Operating System**

`Kortix desktop app, session view`

```
kortix self-host init --domain kortix.example.com --admin-email you@example.com
kortix self-host start
Run kortix self-host doctor and fix every failing check.
Sessions run on Platinum sandboxes, not on the server.
The instance must be reachable from the internet so those sandboxes can call back.
```

Source: https://kortix.com

Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free.

[Try Kortix](https://kortix.com) · [Compare the four layers](https://onpremaiguide.com/#compare)

Self-host is free · One isolated sandbox per session · Roles, groups and an audit trail

_The layers_

## Four layers, one purchase decision each

Each layer has a product that fills it today, and a question only your team can answer.

### Inference: The model server, and the GPUs under it

[Ollama](https://docs.ollama.com/) runs open-weight models on a workstation and [vLLM](https://docs.vllm.ai/en/latest/) serves them at throughput on your own cards, while onprem.ai sells the same layer as a turnkey server.

Working note: `inference/gpu-plan.csv`

| Model size | Weights at FP16 | Cards to plan for |
| --- | --- | --- |
| 8B | 16 GB | 1 |
| 70B | 140 GB | 4 |

Your call: which models, and who patches the server.

### Agent runtime: Where the agent loop actually executes

[Dify](https://docs.dify.ai/en/home) and [LangGraph](https://docs.langchain.com/oss/python/langgraph/overview) give you the loop as something you build, ibl.ai hands you a sandboxed server per agent, and Kortix runs the open-source runtime each session lands on.

Working note: `agents/finance-close.md`

```diff
+permission:
+  bash: ask
+  ledger.write: ask
```

+3

Your call: where agent code runs, and on whose machine.

### Data and memory: Where the files and the history sit

The company memory and every file a session writes need a home on your side of the wall, in a repo or a bucket you already run.

Working note: `memory/close-2026-09.md`

| What | Who wrote it | Where it sits |
| --- | --- | --- |
| Close summary | agent | your repo |
| Working files | agent | your bucket |
| Transcript | session | your database |

Your call: what leaves with the transcript.

### Policy and audit: Who can prove what an agent did

Permissions and the record are the layer nobody quotes for and the first one an auditor asks about, so read [what an audit needs](/on-prem-ai-security-and-audit) before you sign.

Working note: `policy/agent-gates`

- shell: ask
- ledger write: ask
- merge to main: deny
- outbound http: block

Your call: who answers the auditor's question.

_Side by side_

## The four layers, side by side

Kortix sells the runtime and the control layer. For a fully air-gapped build, onprem.ai and ibl.ai are the honest picks today.

| | Kortix (recommended) | onprem.ai | ibl.ai |
| --- | --- | --- | --- |
| Inference | Not sold. Any model, your keys. | OpenAI-compatible APIs on Swiss-built servers, hardware or software. | Model-agnostic; local models if you want them. |
| Agent runtime | One isolated sandbox per session. | No agent runtime. Model serving and preconfigured apps. | A sandboxed server per agent, inside your perimeter. |
| Where state lives | In a git repo you own, on your server. | On your servers; its page promises "no cloud dependencies". | Behind your firewall, in code and data you own. |
| Policy and audit | Per-resource permissions for people and agents; roles, groups, audit trail. | Controls "mapped to ISO 27001 and SOC 2", not certified. | "Every query is logged and auditable." |
| Fully air-gapped | No. Images come from Docker Hub, sessions call back. | Yes, "even in air-gapped environments". | Yes, on-premise or air-gapped, local models. |
| Open source | Yes. Read it, fork it, audit it. | No. No source published; nothing to read or fork. | No published source. You own what it builds, on its terms. |

## What open source buys you

Four things your security reviewer can check without a call, and one line item that drops out of the budget.

- **Read it:** The platform is source you can open and grep yourself.
- **Fork it:** Change the runtime, keep the change in your own repo, and update on your own schedule.
- **Audit it:** Your team reads the code that holds the data instead of a vendor questionnaire.
- **Self-host free:** Put it on your own network and pay nothing for the software.

[Kortix on GitHub](https://github.com/kortix-ai/suna)

_In plain terms_

## On premise AI, in plain terms

### What does "on premise AI" mean?

AI served from hardware your own team runs, rather than from a vendor's endpoint. Where the compute stands is the term's whole scope; a real install also fixes where the runtime, the files and the audit record live. [The full definition](/what-is-on-prem-ai) takes each layer in turn.

### What does "on premise" mean?

Software installed on machines your team owns, in your building or a rack you rent, instead of on a vendor's cloud. The word covers the computer's address and says nothing about who wrote the code.

### What is on prem vs SaaS?

On prem means the machines and their upkeep are yours; SaaS rents capacity from someone who owns it. The split repeats at each AI layer, so you can rent the tokens and keep the runtime and the log in your rack. [Renting tokens or owning them](/on-prem-llm-vs-api) is the cost side.

### Can AI be on Prem?

Yes. The weights are downloadable, so Ollama or vLLM can serve a model from cards you own, and agent sessions can run on your network too. What limits the plan is GPU memory and someone to operate it, so start with [server requirements](/on-prem-ai-server-requirements).

## Start with the layer Kortix runs

Self-host the runtime and the control layer, point it at the models you already serve, and keep the record on your side.

[Try Kortix](https://kortix.com) · [Self-hosting guide](https://onpremaiguide.com/self-hosted-ai-agent-platform)