# Kortix vs LangGraph: which open-source way to run stateful agents fits your team?

> LangGraph gives your engineers a library for long-running, stateful agents. Kortix is the open-source AI Operating System that runs and governs them: one git repo for agents, skills, memory and connectors, a cloud computer per session, and a change request a person approves before work lands.

URL: https://opensourceaiagentframework.com/kortix-vs-langgraph

## LangGraph vs Kortix, side by side

One is a low-level orchestration framework you compose into an application; the other is the open-source system a company runs its agents on.

| | Kortix (recommended) | LangGraph |
| --- | --- | --- |
| What it is | The open-source AI Operating System that runs agents | A low-level library for long-running, stateful agents |
| Open source | Yes. Read it, fork it, audit it | Yes |
| What you own | The whole system in one git repo | The runtime code you write |
| Runs the agents or defines them | Runs them on its own cloud computers | Defines them; you deploy and operate |
| Self-host | Kortix Cloud, your VPC, or on-prem | On your own infrastructure |
| Model choice | Any model, your own keys | Whichever model your code calls |
| Human review of changes | A change request a person approves | Human-in-the-loop you wire in |
| Deployment help | Built in, one platform | LangSmith Deployment, a separate product |

## Every session lands as a change request

`terminal`

```sh
$ kortix cr ls
$ kortix cr diff 1
$ kortix cr merge 1
```

Source: https://kortix.com/docs/quickstart

A session works on its own branch and opens a change request a person reviews and merges.

## A framework builds agents; a platform runs them

LangGraph is a low-level orchestration framework for building, managing and deploying long-running, stateful agents. Its own repository lists the primitives you get: durable execution that resumes a run after a failure, a human-in-the-loop hook that inspects and modifies state, short-term and long-term memory, and tracing through LangSmith. It is a library your engineers compose into an application, and the design is deliberately low-level: prompts, architecture and control flow stay your build.

That is the right shape when the agent runtime belongs inside your own code. Kortix handles the layer where the agents run. Kortix is the open-source AI Operating System: agents, their skills, your company memory and every connector live in one git repo you own, each session runs on its own cloud computer, and work reaches `main` through a change request a person approves. You can read and fork the source through [Kortix on GitHub](https://github.com/kortix-ai/suna).

## What you own and what you operate

With a framework, you own the code and you carry the operation. The runtime, the sandbox, the secrets, the queue and the review step are yours to stand up and keep running, and LangGraph's own deployment story points at LangSmith Deployment, a separate product, for scaling stateful agents.

Kortix moves that half of the work into the platform. A session boots its own isolated machine and branch, connector credentials are brokered server-side so raw keys never reach the agent, and the audit log records every action. The configuration is text in a repo you own, so a teammate can read the history instead of trusting a black box.

## When a team moves from a framework to a platform

Teams reach for a platform once the first prototypes have proved the idea and the questions change from how do we build this to who runs it, who approves it, and where the company's knowledge lives. The framework's flexibility is still there, but it is work you repeat for every agent, and the missing pieces are the shared ones: one place for memory, one review gate before work lands, and one set of permissions for people and agents.

LangGraph stays the better fit when the runtime must live inside your own application and you want to place every interrupt yourself. Kortix is the pick when you want the agents run, reviewed and governed for the whole company, with any model and your own keys. The [Kortix vs CrewAI](/kortix-vs-crewai) page walks the same decision for role-based agent teams, and [Open-source AI agent platforms: how to choose one your team can own](https://kortix.com/blog/open-source-ai-agent-platform) compares five platforms by ownership and deployment.

## LangGraph and Kortix, the questions that decide it

### Is Kortix a replacement for LangGraph?

They sit at different layers. LangGraph is a low-level orchestration framework you compose into an application, and Kortix is the open-source AI Operating System a team runs its agents on. Kortix is the pick when you want the runtime, the review and the governance handled for you.

### What does LangGraph give me that Kortix does not?

Explicit, low-level control of the agent graph inside your own code, with the state and control flow you decide. Kortix makes a different trade: it runs the agents for you, with the configuration and the review gate in one git repo.

### Can I self-host Kortix?

Yes. Run it on Kortix Cloud, in your own VPC, or on your own on-prem network; self-hosting installs the full platform with the `kortix self-host` commands, and self-host is free.

### Is Kortix open source?

Yes. Kortix is the open-source AI Operating System; you can read, fork and audit the code, and the source is on [Kortix on GitHub](https://github.com/kortix-ai/suna).

## Run stateful agents on a system you own

The [Kortix vs CrewAI](/kortix-vs-crewai) page covers the framework choice for role-based teams.

[Try Kortix](https://kortix.com) · [Read the docs](https://kortix.com/docs)

Open source · Any model, your keys · Self-host, VPC, or on-prem