Developers

Your company,
as a git repo.

Coding agents changed how we build software. Kortix brings the same loop to all knowledge work — every agent, skill and automation is a file in one repo you own. Build it locally, ship it with one command, run it as a fleet of cloud sandboxes.

Aacmemain
kortix.toml
read only

The same file viewer you get in the product — pointed at a real Kortix project.

The thesis

The coding-agent paradigm, for all work

Claude Code, Codex and Cursor changed how we build software: describe intent, an agent edits files, you review the diff. Kortix applies that exact loop to the rest of the company — every agent is a coding-agent runtime in an isolated sandbox, pointed at research, ops, support and finance instead of a codebase.

Agents are sandboxes

Every agent runs in its own disposable cloud VM, on its own git branch. Spin up thousands in parallel — nothing is shared between runs.

Work is code

Agents, skills, triggers, connectors and policies are plain files in one repo. Diff them, review them in a change request, roll them back.

You own the stack

Open and source-available. Self-host the exact same stack, bring your own runtime and model keys. No black box, no lock-in.

The loop

From curl to production

One repo, one config, one command. Here is the whole developer loop, top to bottom.

01

Install & scaffold

One line installs the CLI. kortix init scaffolds your project — a kortix.toml manifest and a .kortix/ runtime — wired into the coding agent you already use.

terminal
$kortix init
kortix.toml
.kortix/opencode/
02

Build it locally, like code

Open Claude Code, Codex, Cursor or opencode and build. An agent is markdown — a description, its model, and the tools it can use. Skills are folders it loads on demand. Edit them by hand, or describe what you want and let your coding agent write them.

.kortix/opencode/agents/support.md
---
description: Acme's support agent. Resolves tickets end to end.
mode: primary
model: anthropic/claude-opus-4-8
tools:
  lookup_order: true
---

You are Acme's support agent. Resolve customer tickets
end to end, with full product and order context.

Issue refunds under $500 on your own. Anything higher
goes to a human for approval.
03

Declare the whole company in one manifest

kortix.toml is the source of truth for everything operational: env and secrets, sandbox images, cron and webhook triggers, 3,000+ connectors, Slack channels, even deployable apps. Versioned from the first commit.

kortix.toml
kortix_version = 1

[project]
name = "acme"

# the OpenCode runtime config dir
[opencode]
config_dir = ".kortix/opencode"

# a trigger runs itself, on a schedule
[[triggers]]
slug = "daily-digest"
type = "cron"
agent = "research"
cron = "0 0 9 * * 1-5"
prompt = "Summarize yesterday across Slack & Linear"

# connect a tool's API as agent tools
[[connectors]]
slug = "stripe"
provider = "http"
base_url = "https://api.stripe.com"

# answer where your team works
[[channels]]
platform = "slack"
agent = "support"
04

Ship it

kortix ship commits, pushes, creates the cloud project, links your repo, and prompts for any missing secrets. Triggers, webhooks and channels go live immediately — no separate infra to stand up.

terminal
$kortix ship
committed & pushed to main
secrets synced · sandbox built
live — triggers & channels running
05

It runs as a fleet of sandboxes

Every session is its own isolated VM on its own git branch, booting the runtime and your repo. Spawn thousands of agents in parallel — zero interference. Agents commit their work, and a change request is the only way it reaches main, so everything is reviewable and reversible.

sessions
main ──────●────────●────────●────▶
├─ session 1f3a sandbox ─╮
├─ session 9b22 sandbox ─┤ change
├─ session 4e07 sandbox ─┤ requests
└─ … ×1000 sandboxes ─╯
 
review → merge → main
06

Bring your own runtime & model

Sessions run on an open runtime, pluggable by design. Bring your own model keys — Anthropic, OpenAI, local — or use Kortix compute. Nothing about the runtime is hidden.

terminal
$ kortix providers login anthropic
using your own key (byo)
 
# or point at any runtime / model
$ kortix providers set --model opus-4.8
$ kortix providers set --model gpt-5
One CLI

The whole lifecycle, from your terminal

Scaffold, ship, run, automate, connect and review — one CLI does it all. The same binary is pre-authenticated inside every sandbox, so agents drive Kortix with the exact commands you do.

Scaffold & ship

kortix init

Scaffold kortix.toml + .kortix/

kortix ship

Commit, push, link & go live

kortix validate

Type-check your manifest

Run & talk

kortix sessions

Spawn & manage sandbox sessions

kortix chat

Talk to a session's agent

kortix files

Browse the repo, diffs & branches

Automate

kortix triggers

Cron & webhook automations

kortix channels

Connect Slack & chat surfaces

Connect

kortix connectors

Wire up 3,000+ tools

kortix secrets

Manage encrypted secrets

kortix env

Pull / push as dotenv

Review

kortix cr

Open, review & merge change requests

kortix access

Invite, grant & revoke access

Operate

kortix self-host

Run your own Kortix cloud

kortix hosts use

Switch cloud ↔ local

kortix providers

Bring your own model keys

Open & yours

Yours to run, anywhere

Kortix is source-available — read it, fork it, audit every line. Self-host the exact same stack on a laptop, a VPS, your VPC, or fully air-gapped.

kortix-ai/suna · stars
A leading open AI workspace — star it, fork it, self-host it.

Self-host anywhere

A laptop, a VPS, your own VPC, or fully air-gapped — the exact same stack as Kortix cloud.

Any runtime

An open runtime today, pluggable by design. The sandbox is yours to read and replace.

Any model

Bring your own keys — Anthropic, OpenAI, or local models — or run on Kortix compute.

terminal
$kortix self-host start
your own Kortix cloud, from Docker images
Start building

Ship your first agent in minutes

Install the CLI, run kortix init, and build your company like a codebase.

Open · source-available · bring your own models

Kortix – The Autonomous Company Operating System