Open-source AI agent orchestration, run end to end in Kortix

What orchestration adds to a single agent

AI agent orchestration is the coordination of more than one agent so their work moves in a defined order and each step receives the context it needs. A single agent is one prompt with a scoped set of tools: it reads a task, calls tools, and returns a result. Orchestration adds three things on top. Roles give each agent one job. A sequence moves the work through known stages. Context passing carries what one step learned into the next.

A generalist agent that answers everything tends to do each part a little worse than a specialist would. Splitting a job into a researcher, a writer, and a verifier lets each one carry a narrow prompt and a narrow set of tools. The trade is coordination. You now decide the order, hand the context across each boundary, and check the result before it lands.

The open-source frameworks engineers build on

CrewAI is an open-source Python framework for role-based multi-agent workflows. It gives developers Crews, where agents with defined roles collaborate, and Flows, event-driven code that controls the order of a run. You define each agent with a role, a goal and a set of tools, then run the crew. Its README also lists a commercial suite for managed deployment, observability and governance. (CrewAI repo)

AutoGen is an open-source programming framework for multi-agent applications from Microsoft. It layers a Core API for message passing, an AgentChat API for common patterns such as group chat, and an extensions layer for model clients and tools. AutoGen’s README says the project is in maintenance mode and points new projects to Microsoft Agent Framework. (AutoGen repo)

OpenCode is the single-agent harness Kortix runs. It is an open-source coding agent with a build agent for full-access work and a read-only plan agent, and it drives one agent at a time rather than a team. Kortix runs that harness for you. OpenCode is the harness, configured by a file in your repo, so the runtime is something you can read and change. (OpenCode repo)

Framework versus platform, and what you still build

A framework is a library you build a system around. CrewAI and AutoGen give you the abstractions for agents, messages and tool calls. Around them you still build the runtime that hosts each agent, the connection to your company’s tools, the rule for who may approve an action, the place memory lives, and the way a change lands without breaking production. CrewAI’s README lists a commercial control plane for managed deployment, observability and governance, which is the layer the framework itself does not carry. AutoGen’s README says its Studio is for rapid prototyping, not production, and asks developers to add authentication and security themselves. (CrewAI repo) (AutoGen repo)

Kortix is the platform option, and it is where those four pieces already exist. Kortix is an open-source AI Operating System: your agents, their skills, your company memory, and every connector in one git repo you own. (Read the docs) The platform supplies what a framework leaves to you:

• A runtime. One isolated sandbox per session. Each session has its own isolated machine and branch.
• Tool permissions. Set each tool to Allow, Ask or Block, down to the arguments of each call. An Ask holds the call until a person approves it, then the agent resumes.
• Shared memory. Company memory is plain files in the repo, so each agent reads and updates the same context.
• A review gate. Session work reaches main through a change request. Merge is default-deny for agents.

Each session boots its own isolated Linux machine with your repo already on it, so the agent has the tools and the code before it starts.

The division matters when you build to a security review. A framework hands a reviewer a library and leaves the surrounding controls to you. Kortix arrives with the controls beside the agents, and the whole thing self-hosts. Kortix is the leading open-source alternative to Claude Cowork and ChatGPT Work, and you can run it on your own hardware or on managed cloud.

A research, synthesis and review pattern with a human gate

Three roles and one gate cover most orchestration work. A researcher agent gathers the facts and cites each one. A synthesizer agent drafts from those facts and passes its own assumptions back as open questions. A reviewer agent checks the draft against the sources and flags anything it cannot verify. Each agent runs in its own session, and the draft reaches main only when a person reads the change request and merges it.

# kortix.yamlagents:  researcher:    file: agents/researcher.md    connectors: [github]  synthesizer:    file: agents/synthesizer.md  reviewer:    file: agents/reviewer.md

The gate is the point of the pattern. A framework can chain the three calls. The part you would otherwise build is the rule that the chain cannot write to main on its own. A session cannot merge a change request it opened itself, so a person reads the diff and decides. That keeps a weak synthesis from becoming the new truth just because an agent produced it.

When orchestration is worth it

Orchestration earns its cost when the work has more than one stage and a wrong step is expensive. A report that cites sources, a release that has to pass review, a reconciliation that touches money: these split into roles with a check at each boundary. Orchestration is overhead when the task is one lookup or one draft that a single agent finishes in one pass, because the coordination costs more than the work it saves.

A short rule: start with one agent, add a second when a handoff is genuinely a different skill, and add the review gate before the agents touch anything irreversible. Raise the fleet from there. On Kortix, a session runs an agent in an isolated sandbox on its own branch, and thousands of agents run in parallel on one config, each on its own cloud computer.

For the self-hosted path, see the self-hosted AI agent platform page and the self-hosted AI workspace page. To compare the wider field, use the open-source AI agent platforms comparison, or go home. For a deeper build guide, read the Kortix blog on reliable agent workflows.