# Pick an open-source agent fleet platform by what it leaves you

> An open-source agent fleet platform runs the agents, and the fleet itself is a set of files the company keeps. Kortix is the open-source CompanyOS: your agents, skills, memory, and connectors in one repo you own.

URL: https://runanagentfleet.com/agent-fleet-platforms-compared

## Where each platform keeps the fleet

Four products that run a fleet, the place each one keeps the definition and the policy, and where its record comes from.

| | Kortix (recommended) | NanoFleet | OpenManager | Mission Control |
| --- | --- | --- | --- | --- |
| What it is | CompanyOS: agents, skills, memory and connectors in one repo | Self-hosted fleet manager, one container per agent | Control plane on Hermes Agent, with the OMAP spec | Self-hosted control plane, described as alpha |
| Where the agent definition lives | Files in one git repo you own | An Agent Pack zip: persona, tools, skills | Registered through the OMAP spec | In its own database, behind its dashboard |
| Where policy and approvals live | Actions are always_run, require_approval, block, shown as Allow, Ask, Block | Container limits and network isolation per agent | The OMAP spec covers registration and authentication | RBAC, audit history and trust scoring |
| What record survives the subscription | Definitions in your repo; audit record from the runtime, per plan | The install and its Agent Packs, on your own host | An audit log of every message routed, in your install | Sessions, logs and memory in your install |
| Self-hosting | Cloud, your VPC, or on-prem | Docker Compose on your own host | Self-hosted; free tier is 5 sub-agents | Self-hosted, no account required |
| Open source | Yes | Yes | Yes | Yes |

Each rival column states what that product documents on its own page, checked November 2026.

## What each agent is allowed to do, printed by the CLI

`kortix validate`

```
  ✓  kortix.yaml is valid
What each agent enables:
  foreman  skills=[fleet-registry, fleet-policy]  subagents=[worker, auditor]  commands=[none (default-deny)]  extensions=[none (default-deny)]  connectors=[warehouse]  secrets=[none (default-deny)]
  worker  skills=[fleet-policy, fleet-audit]  subagents=[none (default-deny)]  commands=[none (default-deny)]  extensions=[none (default-deny)]  connectors=[warehouse]  secrets=[none (default-deny)]
  auditor  skills=[fleet-audit]  subagents=[none (default-deny)]  commands=[none (default-deny)]  extensions=[none (default-deny)]  connectors=[none (default-deny)]  secrets=[none (default-deny)]
```

Source: https://github.com/Kortix-seo/agent-fleet-starter

The validate output for the three-agent fleet in [agent-fleet-starter](https://github.com/Kortix-seo/agent-fleet-starter). Each `none (default-deny)` column is a grant the agent does not have, so worker cannot start a subagent and auditor cannot call a connector at all.

## What a fleet platform gives you, and what it keeps

The products that run agent fleets fall into two groups. One group is frameworks and clouds: [CrewAI](https://www.crewai.com/), [Salesforce Agentforce](https://www.salesforce.com/agentforce/), [Amazon Bedrock AgentCore](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html), the [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/), [IBM watsonx Orchestrate](https://www.ibm.com/products/watsonx-orchestrate), [Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/overview/), [n8n](https://n8n.io/), [Dify](https://dify.ai/), [OpenHands](https://www.openhands.dev/), [AgenticFleet](https://github.com/Qredence/agentic-fleet) and [LangGraph](https://www.langchain.com/langgraph). The other is products with fleet in the name, built for the job of running many agents at once.

Both groups run agents. The difference that matters a year later is smaller and duller: where the definition of an agent lives, and what record survives the subscription. A cloud runtime keeps the definition in its builder and the run log in its store. A framework keeps the definition in your code, which is better, and the policy and the audit come from whatever you build around it, or from a control plane the vendor sells.

## The fleet-named products

Three of them answer the question a fleet owner asks, and the rest are one line each.

NanoFleet is a self-hosted fleet manager where every agent runs in its own Docker container with resource limits and network isolation. Plugins are MCP servers in separate containers, an Agent Pack is a zip file holding an agent's persona, tools and skills, and the install is Docker Compose ([nanofleet.ovh](https://nanofleet.ovh/)).

OpenManager is an open-source control plane for deploying, connecting and orchestrating a fleet, built on Hermes Agent. Its OMAP spec covers how agents register, authenticate, discover capabilities, exchange messages and share skills, and the dashboard shows each agent's health plus an audit log of every message routed and by whom. The free tier allows 5 sub-agents per install ([openmanager.dev](https://openmanager.dev/)).

Mission Control is open source, self-hosted and alpha. Sessions, logs, memory and token usage sit in one view, with a six-column task board, scheduled workflows, RBAC, audit history, trust scoring and secret detection. Adapters cover OpenClaw, CrewAI, LangGraph, AutoGen and the Claude SDK ([mc.builderz.dev](https://mc.builderz.dev/)).

Fleetify is a command center with a provider per session and a spend cap ([fleetify.dev](https://fleetify.dev/)). herdctl is a YAML fleet over Claude Code, with Docker isolation and resumable sessions ([herdctl.dev](https://herdctl.dev/)). AgentsRoom is a desktop app over the coding-agent CLIs, with a branch per agent ([agentsroom.dev](https://agentsroom.dev/ai-agent-fleet)). agentFleet is a control plane for coding fleets, with a git worktree per agent and review gates before merge ([agentfleet.live](https://www.agentfleet.live/)).

## The platforms a reader chooses between

The frameworks and clouds give you a runtime. Several of them ship the governance with it. CrewAI's control plane traces every call and keeps immutable audit trails, with human-in-the-loop approval gates ([crewai.com](https://www.crewai.com/)). n8n has approvals, audit logs and RBAC ([n8n.io](https://n8n.io/)). OpenHands runs an Agent Control Plane over who can run agents, what they can access and what they change ([openhands.dev](https://www.openhands.dev/)). The definition can be code, a builder export or a workflow file in git. The policy still sits in the product's own control plane, on the product's terms. A repo puts both halves in one file. The diff is the record.

Two products come up in the same search. LangSmith Fleet is a no-code builder whose agents work in Slack, Teams and Gmail, with tool-level approval requirements and a central agent inbox ([langchain.com](https://www.langchain.com/langsmith/fleet)). FleetQ is an open-source orchestration tool you run yourself on Docker Compose, with a visual DAG, a per-tier risk policy of auto, ask or reject and a credit ledger ([github.com](https://github.com/escapeboy/agent-fleet-o)). Both keep the fleet's definition in their own store.

## Kortix, worked

Kortix is the open-source CompanyOS. The registry is the `agents:` block, the policy is a permission key per tool, and a change to either is a diff a person reviews ([kortix.com](https://kortix.com)).

The validate output comes from [agent-fleet-starter](https://github.com/Kortix-seo/agent-fleet-starter), a three-agent fleet in a public repository. Read the columns: foreman can start worker and auditor, worker cannot start a subagent, and auditor cannot call a connector at all. Each `none (default-deny)` column is a grant the agent does not have, so widening one shows up as a diff in the change request a person reviews.

A fleet can start from a manifest this short:

```yaml
# yaml-language-server: $schema=https://kortix.com/schema/kortix.schema.json
default_agent: assistant

agents:
  assistant:
    description: Answers questions about the project.
    prompt: You answer questions about this project. Read the files before you answer.
    tools: all                               # omitted: all, with a warning
    skills: all                              # omitted: no skills
    workspace: { project_repository: true }  # omitted: no repository in /workspace
```

Source: https://kortix.com/docs/developers#kortixyaml-reference (the manifest reference, which lists every key in this block and what an omitted one does).

Each block under `agents:` is one agent: a description, a prompt, the tools and skills it may reach, and its workspace. The file is the registry, and a change to it is a diff. The three-agent fleet behind the output adds a policy block and two more agents, and the same command prints what each one enables.

## The decision guide

Three cases, and the first question is what you need to keep.

A hosted platform is the right call when the fleet is small, the work belongs to one team, and the record you need is a run log for this week's debugging. Agentforce fits a company already on Salesforce. Bedrock AgentCore fits a team on AWS that wants modular services and a managed agent loop. LangSmith Fleet fits a team that lives in Slack, Teams and Gmail and wants a no-code builder and a central agent inbox.

A self-hosted control plane is the right call when you need routing and a dashboard, and someone on the team will run the box. Mission Control, OpenManager and agentFleet are control planes you install. NanoFleet, FleetQ and herdctl are runtimes with a scheduler. Fleetify and AgentsRoom are dashboards over the coding-agent CLIs a team already has.

The fleet belongs in a repo when it answers to a policy, when an approval has to attach to the action it covers, and when someone will ask next year which agent changed what and who approved it. That is the case Kortix is built for, and the file does most of the work: the definition and the history of every change travel with a clone.

The policy in that file is a setting a person makes, and the record it leaves is the part that outlives the subscription. Every action is recorded.

Where it runs is a separate choice. Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free. Open source. Read it, fork it, audit it.

## The platform choice, answered

Short answers on the choice, the deployment and the record.

### Which platform is the best for AI agents?

Kortix, for a fleet that answers to a policy. A hosted platform is the better pick when the fleet is small, one team owns it, and this week's run log is the only record you need; LangSmith Fleet fits a team already in Slack, Teams and Gmail.

### What is the best platform for deploying AI agents?

Kortix, when the fleet has to answer to a policy. A hosted platform deploys agents in an afternoon and keeps the run log in its own store, which suits a small fleet. A repo keeps the definition and the policy as files you can read later.

### What is an AI agent fleet?

An AI agent fleet is several agents run as one unit, under one policy, with one record of what each of them did. The fleet is the unit a company governs, and the platform is only the runtime it runs on.

### Where do AI agents run?

In a sandbox or a cloud runtime, depending on the platform. In Kortix, every session runs on its own isolated cloud computer. A session never touches your laptop or another session.

## Point the platform at a fleet you own.

One repo holds the agents and the policy, and the runtime keeps the record.

[Try Kortix](https://kortix.com)