If you self-host Open WebUI, you own the server it runs on, and most of the work your team does inside it still lives as chat history and uploaded files. Open WebUI is a self-hosted AI platform that runs offline and puts a chat interface over your own models, connecting Ollama and any OpenAI-compatible API. Kortix is the open-source AI Operating System: your agents, their skills, your company memory, and every connector live in one git repo you own, and each session runs on its own cloud computer. The distance between those two sentences is the whole question. One arrangement self-hosts an interface. The other self-hosts a body of work you can read, diff, and move.
What Open WebUI is, and where it is strong
Open WebUI is a self-hosted AI platform that gives a team a chat window over models it already runs or rents. The project supports Ollama and any OpenAI-compatible API, so the same interface can point at a local model, a hosted provider, or a model server on your own network. Its repository lists plugins such as filters, actions, pipes, and tools, plus MCP and OpenAPI tool servers, per-user groups and granular role-based access control, local retrieval over nine vector databases, persistent memory across conversations, and usage analytics. The same repository carries more than 150,000 GitHub stars and shipped its v0.12.0 release on October 10, 2026 (checked October 2026).
The project has grown past chat. Open Terminal gives an agent a terminal and a filesystem inside the chat so it can run scripts and hand back files, and Terminals adds per-user isolated environments with resource limits on top. A separate companion app, Computer, runs an agent on the machine you own. Open WebUI's own documentation draws the line itself: Open WebUI is the stable, multi-user platform teams deploy, and Computer moves faster on a real machine. That is a mature product with a large community whose center is still the interaction.
The self-hosting question people actually have
Most self-hosting guides answer how to install Open WebUI. The documented quick start is one docker run command that publishes port 3000, mounts a data volume, sets a secret key, and restarts the container. Everything past that, a database, file storage, optionally Redis, and a vector database for retrieval, is a choice you make and then operate.
The footprint is small, and it is why Open WebUI spread quickly. The question worth asking is a different one: when the work is finished, what of your team's output survives inside that footprint, and who can read it, version it, or take it with them.
What a self-hosted chat instance actually owns
A self-hosted Open WebUI instance owns the surface, and it stores your team's work in the places a web application normally stores data. Conversations sit in a database, which Open WebUI lets you run as SQLite or PostgreSQL. Uploaded documents sit in file storage, on the local disk or in S3, Google Cloud Storage, or Azure Blob Storage. Retrieval vectors sit in one of the nine supported vector databases. Accounts, groups, and permissions sit in the same application database. Plugins and custom functions are code you install into the running instance.
You own all of it, because you run the server. What you do not get is a versioned record of the work itself. A conversation is a row, an uploaded file is an object, and a knowledge base entry is an embedding. None of them is a diff you can review before it lands or roll back after it ships. A second Open WebUI instance on another machine starts empty, because the state travels as a database dump rather than as files.
What a self-hosted agent platform owns instead
Kortix is the open-source AI Operating System, and it treats a company's working state as source. Agents and skills are markdown files. kortix.yaml declares the machine image, the connectors, the triggers, and the secret names and grants. Company memory is files that accumulate. If you can grep a directory, you can inspect the whole configuration, and you can roll any part of it back with git. The project carries 20,000+ GitHub stars and you can read it, fork it, and audit it on Kortix on GitHub.
The runtime is where the two products diverge most. In Kortix, every session boots its own cloud computer, an isolated sandbox on its own branch, and the agent can install, run, and break anything on that machine while only what it commits survives. When the work is ready, the agent opens a change request, and merge is default-deny for agents, so a person reads the diff before it reaches main. The unit of work is a reviewable change that lands through a person's approval.
Kortix runs any model provider with your own keys, including the ChatGPT plan you already pay for. It connects 3,000+ apps in a click, plus MCP, OpenAPI, Postman, GraphQL, and raw HTTP, and connector credentials are brokered server-side and never enter the machine. You can run it on Kortix Cloud, in your VPC, or on your own on-prem network, and self-host is free. The Kortix docs describe the repo, the session, and the change request as one loop.
The ownership split, in one table
| Dimension | Kortix | Open WebUI |
|---|---|---|
| Open source | Yes | Yes |
| What you run | A repo plus the hosting you choose | One container plus your database and storage |
| Where work lives | A git repo, versioned and diffable | A chat database and file storage |
| How work lands | A change request a person reviews | Directly in the conversation |
| Agents | On isolated cloud computers, one branch per session | Open Terminal gives an agent a terminal inside the chat |
| Models | Any provider, your own keys | Ollama and OpenAI-compatible APIs |
| Team governance | Per-resource permissions, approval gates, an audit trail | Roles, groups, and per-user access control |
| Configuration | Files in a repo you own | Instance settings and a database |
Where Open WebUI stops and an agent platform begins
Open WebUI's center is the interaction: a person asks, a model answers, and tools and retrieval add context. Open Terminal and the Computer app push that center toward action, and the project's own docs say the fast-moving real-machine work ships in Computer first. Even so, the artifact of an Open WebUI session is a conversation, and the artifact of a Kortix session is a finished deliverable, a report, a deck, a patch, or a reply, that lands as a change somebody reviews.
The two projects agree on this boundary. Kortix's own README lists Open WebUI among the tools that fit "a chat window or search over company documents," and places Kortix in the category of agents that return finished work and take real actions in your tools. Open WebUI's docs, in turn, present it as the stable platform and Computer as the faster one. A side-by-side comparison of Kortix and Open WebUI works through the same split dimension by dimension.
The operational cost self-hosting teams underestimate
Self-hosting carries real work whichever platform you pick, and the work takes a different shape in each. Open WebUI's enterprise documentation describes a stateless application layer that scales by adding replicas behind a load balancer, with shared databases, storage, and Redis keeping those replicas coordinated. That is a familiar web stack, and it means your platform group runs a database, object storage, and Redis alongside the app. The same page puts responsibility for SOC 2, HIPAA, GDPR, and ISO 27001 posture on the deploying organization.
A self-hosted Kortix instance runs as one Docker Compose stack: the frontend, the API, the LLM gateway, and its Supabase distribution, with no Redis and no separate worker, so there is less to operate on the control plane. Agent sessions run on a separate sandbox provider rather than on that stack. On governance, Kortix adds per-resource permissions for people and agents, approval gates you set that stay off until you turn them on, and an audit trail whose recording is never gated. Open WebUI provides roles, groups, and role-based access control, and places dedicated support and long-term options behind a paid enterprise agreement.
How to decide which one to self-host
Two questions decide it, and neither is about which product is more capable.
The first is what the output of a session has to be. If the answer your team wants is a conversation, a search result over documents, or a summary, Open WebUI is built for that and does it well, on hardware you control, with a wide model list and a plugin surface that keeps growing. If the answer has to become a file, a fix, a report, or an action inside another tool, the platform that produces and reviews that deliverable is the one to run.
The second question is where the review happens. In a chat interface, review means reading what the model wrote and deciding whether to use it. In an agent platform, review means a diff on a change request, with merge held until a person approves it and the configuration that produced the work sitting in git beside it. Teams that need a record of what changed and why tend to find the second shape matches how their work is already governed.
You are not forced to pick one forever. Some teams keep a self-hosted chat interface as the front door for questions and run the work that has to ship on an agent platform behind it.
Frequently asked questions
Is Open WebUI open source?
Yes. Open WebUI publishes its code and runs offline on hardware you control, and the project is free to deploy as-is. Its enterprise page separates that free internal use from a paid enterprise agreement that covers white-labeling, rebranding, and enterprise-only features such as Terminals.
Can I self-host Kortix for free?
Yes. Self-host is free, and the software runs as one Docker Compose stack on your own machine, VPC, or on-prem network. Managed Kortix Cloud is the paid option, at $40 per seat per month plus usage, with a free tier that includes 200 credits a month and one project.
Do Open WebUI and Kortix do the same job?
They sit at different layers. Open WebUI is a self-hosted chat interface over your models and documents, now with terminal and computer companions. Kortix is an agent platform where each session runs on its own cloud computer and returns finished work that lands through a change request.
What does "what you actually own" mean when self-hosting?
You own whatever runs on your hardware in both cases. The difference is the shape of what you own. Open WebUI gives you an application and its database and files. Kortix gives you a git repo where the agents, skills, memory, connectors, and triggers live as files you can version and roll back.
The short version
Self-hosting is the right instinct, and it answers only half the question. A self-hosted Open WebUI gives a team a chat interface and a model layer it controls. A self-hosted Kortix gives a team ownership of the work itself: one git repo, every agent session on its own cloud computer, and every change reviewed before it merges. Start from the repo, run the first job, and read the diff at Try Kortix.
Top comments (0)