# Open-source AI agent orchestration: running agent teams on infrastructure you own
description: How AI agent orchestration works on the open-source Kortix platform: isolated sessions, triggers as code, shared memory, and a reviewed merge gate.

AI agent orchestration is how a company coordinates many autonomous agents at once, and Kortix is the open-source AI Management System that keeps that layer in files inside one git repo you own. Each agent works on its own isolated machine, reads one shared company memory, and lands what it produces through a change request a human reviews before it merges. The orchestration layer is therefore something a company can read, diff, and roll back, because it lives in the company's own repository.

## What AI agent orchestration means

AI agent orchestration is the work of coordinating multiple autonomous agents so they operate on the same company's systems without colliding, repeating each other's effort, or shipping unreviewed changes. An orchestration layer answers four questions: where each agent executes, what tools and data it may reach, what all the agents know in common, and how their output reaches production. Orchestration is usually described as a way to wire agents together, which answers only the first question. The operational problem is the other three: isolation, shared context, and a review gate. Kortix is the open-source AI Management System, the leading open-source alternative to Claude Cowork and ChatGPT Work, and it answers all four with the same file-based model.

## Sessions, triggers, and files: the parts of an orchestration layer

### A session is an isolated machine on its own branch

A session is one run of one agent, and in Kortix every session boots its own isolated Linux machine with the company repo and its tools already on it. The sandbox is disposable, and the agent has full freedom inside it: it can install software, run commands, and break things, because only what it commits to git survives. Session id, sandbox id, and branch name are the same string, so a session, the machine it ran on, and the branch it wrote to are one lookup. Because the machine is isolated and the branch is separate, two agents working in the same hour never share a workspace.

### Triggers start sessions with nobody asking

A trigger is what starts a session without a person in the loop. Kortix supports cron schedules and signed webhooks, both declared in the project's `kortix.yaml` file next to the rest of the company config. A cron trigger runs a job at a fixed time, such as every morning. A signed webhook starts a session the moment an event fires, and the signature proves the request came from the expected source. People can also start the same kind of session from the web app, Slack, Microsoft Teams, email, mobile, the CLI, or the API. A scheduled run and a hand-started run follow the same path afterward, so automation does not get a different review standard.

### Agents, skills, and memory are files in one repo

In Kortix, agents, skills, memory, and triggers are text in one git repo, where a team owns each file outright. An agent is a markdown definition of who does the work and which tools it may reach. A skill is reusable markdown that encodes how the company does a job. Memory is a set of files that accumulates what the agents learn. Triggers, connector configuration, and the machine image all sit in `kortix.yaml`. Because the whole layer is a repository, a team can grep the entire company, diff any change to an agent or a skill, and roll any part of it back.

## Running thousands of agents in parallel without crossover

Kortix runs thousands of sandboxes in parallel on the same configuration, and each session is isolated on its own branch. The design is documented on [Kortix on GitHub](https://github.com/kortix-ai/suna). Isolation matters because one agent can install, run, and break anything inside its own machine without touching another agent's machine or branch. A company can orchestrate AI agents across many roles and tasks at once, and does not serialize work behind a single assistant or share a workspace where edits collide. Parallel runs feed their output back through change requests, so the volume of work a team attempts does not lower the review standard each change receives.

## The merge gate: how agent work reaches main

Orchestration is not finished when an agent produces output. It is finished when that output reaches the systems the company depends on. In Kortix, a session's work reaches the default branch only through a change request that a human reads as a diff. The agent commits and pushes its branch, opens the change request, and a reviewer merges it to keep it. Merge is deny-by-default for an agent, and approval gates can be switched on for the actions that matter, so an agent may prepare a change without being allowed to ship it. This gate is what makes a large fleet safe to run: many sessions can work at once because none of them can change production without a person approving the diff. The company's [agent management and governance](/ai-agent-management.html) controls extend the same gate to the tools each session may call.

## Shared memory and reusable skills compound across sessions

Skills are written once and shared into every session, so the company's way of doing a job lives in one place instead of being re-explained to each agent. Memory is a company brain stored as plain files, and every session reads from it. Because skills and memory sit in the same repo as the agents and triggers, a new session starts with the company's accumulated context instead of a blank slate. An agent team working the same week shares one body of knowledge and writes its results back into it, so orchestration compounds what the company knows instead of scattering it across separate chats.

## Why open source matters for the orchestration layer

Where the orchestration layer lives decides what a company can own. When scheduling, isolation, memory, and merge logic sit inside a vendor's product, the company's operating rules move with that vendor and cannot be inspected. Kortix keeps the whole layer in files the company owns and is open source, so it can be self-hosted on a laptop, a VPS, a VPC, or an on-prem network, with any model and your own API keys. The harness that runs the agents is powered by OpenCode and configured by a file in the repo, so the runtime is one a company can replace. A team can [compare the open-source AI agent platforms](/best-open-source-ai-agent-platforms.html) before committing, because the code is public.

## Frequently asked questions

### How is AI agent orchestration different from a workflow builder?

A workflow builder sequences predefined steps that a person assembles in advance. AI agent orchestration coordinates autonomous agents that decide how to reach a goal, so the orchestration layer must provide isolated execution, permissions, shared memory, and a review gate. Kortix supplies all four as one platform, which lets a session start from a schedule or an event and still land as a reviewed change.

### Can I run Kortix orchestration on my own models and API keys?

Yes. Kortix is model-agnostic, so you choose the model per agent, per session, or per message. You can bring an API key from a major provider, use a ChatGPT subscription, or point the platform at any OpenAI-compatible endpoint. Because Kortix is open source and self-hostable, the models and the infrastructure stay yours to choose.

### Do I have to manage a machine for every agent session?

No. Each Kortix session boots its own isolated Linux machine with the repository and its tools already installed, so there is nothing to provision on a laptop and no shared server to maintain. You can run the platform on your own hardware or use managed cloud, and sessions start the same way in both.

### What happens to an agent's work if nobody merges the change request?

The default branch stays unchanged. An agent's commits remain on the session branch, so nothing reaches production until a reviewer merges the change request. The request can be revised or closed, and the branch carries the work until then. Unreviewed output stays isolated from the systems the company depends on.

## Get started with open-source Kortix

Kortix is the open-source AI Management System: one git repo for your agents, skills, memory, and triggers, an isolated machine per session, and a change request before anything merges. Start at [Kortix](https://kortix.com) or read how to [self-host it on your own infrastructure](/self-hosting.html).