Developers

Your company,
as a git repo.

Coding agents transformed how we build software. Kortix brings the same paradigm to 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.

acme — kortix
$ curl -fsSL kortix.com/install | bash
$ kortix init acme
created kortix.toml
created .kortix/opencode/
wired claude · codex · cursor
 
$ kortix ship
pushed to main · sandbox snapshot built
acme is live — triggers & channels running
$
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, just 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 source and self-hostable. Bring your own runtime and model keys. No black box, no lock-in — read every line.

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 a project — a kortix.toml manifest and a .kortix/ runtime — and wires Kortix into the coding agent you already use. Start from the general-knowledge-worker template with 60+ ready-made skills, or from minimal.

terminal
$ kortix init acme --template general-knowledge-worker
kortix.toml
.kortix/opencode/agents/
.kortix/opencode/skills/ 60+ skills
.kortix/opencode/tools/
wired .claude/ · AGENTS.md · .cursor/
02

Build it locally, like code

Open Claude Code, Codex, Cursor or opencode and build. Agents and skills are markdown — a persona, its model, its skills and tools. Edit them by hand, or just describe what you want and let your coding agent write them. It is a coding framework for knowledge work.

.kortix/opencode/agents/support.md
---
name: support
model: claude-opus-4-8
skills: [refund-policy, ticket-triage]
tools: [gmail, stripe, slack]
---
 
You are Acme's support agent. Resolve tickets
with full product context. Anything over
$500 → human 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
[project]
name = "Acme AGI"
 
[[triggers]] # runs itself, on a schedule
type = "cron"
cron = "0 0 9 * * 1-5"
prompt = "Summarize yesterday across Slack & Linear"
 
[[connectors]] # 3,000+ tools as agent tools
provider = "pipedream" · app = "slack"
 
[[channels]] # answer where your team works
platform = "slack" · agent = "support"
04

Ship it

kortix ship commits, pushes, creates the cloud project, links your repo (GitHub or managed), 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
linked github.com/acme/agi
secrets synced (3)
sandbox snapshot built
 
live — triggers scheduled · channels connected
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 hundreds of thousands of agents in parallel — zero interference. Agents commit and push 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 the open-source OpenCode runtime today, pluggable by design — Codex and cloud runtimes are on the roadmap. 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

Company as code

No black box

One repo is the source of truth. Every agent, skill, trigger and policy is a plain file — versioned in git, reviewed in a change request, deployed in one command, and portable between cloud and self-host.

acme/
acme/
├─ kortix.toml # the company, declared
├─ .kortix/
│ ├─ Dockerfile # the computer
│ └─ opencode/
│ ├─ agents/ support.md · research.md
│ ├─ skills/ refund-policy/ · deep-research/
│ ├─ tools/
│ └─ memory/ # the company brain
└─ README.md
[project]
name = "acme-agi"
 
[[triggers.cron]]
agent = "briefing"
schedule = "0 8 * * *"
 
[[channels]]
type = "slack" · agent = "support"
 
[connectors]
required = ["gmail", "stripe", "slack"]
Open source

Yours to run, anywhere

Kortix is open source — 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

OpenCode runtime today, pluggable by design — Codex and cloud runtimes are on the roadmap.

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
$ kortix hosts use local kortix hosts use cloud
Start building

Ship your first agent in minutes

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

Open source · self-hostable · bring your own models

Kortix – The Autonomous Company Operating System