# Open-source autonomous AI agents: where the rules live

> Four projects come up for open-source autonomous AI agents: Kortix, OpenHands, OpenClaw and Hermes Agent. They are four different kinds of tool. What separates them is whether the agent's rules, memory and connectors are files your team can open, and whether a person merges what a run produced. Kortix is the open-source AI Operating System.

URL: https://autonomousaiagentsguide.com/open-source-autonomous-ai-agents

## Which open-source agent keeps its rules where your team can read them?

Four open-source agent tools, and the place each one keeps the rules a run follows.

| | Kortix (recommended) | OpenHands | OpenClaw | Hermes Agent |
| --- | --- | --- | --- | --- |
| Open source | Yes | Yes | Yes | Yes |
| What it is | Open-source AI Operating System, configured as files | Self-hosted developer control center for coding agents and automations | An AI assistant on your own computer, in your chats | A self-improving terminal agent built by Nous Research |
| Where the rules live | Files in the project repo: `kortix.yaml`, agents, skills, memory | In the Agent Canvas frontend; agents run on your backends | On your hardware, in one Gateway's configuration | In one gateway process, set from its CLI |
| How a run starts | Cron, signed webhook, app event or monitor command | Manually, or an automation on a schedule or webhook | A message in a chat channel you already use | A built-in cron, or a message from the TUI or a chat app |
| Models | Model-agnostic: pick the model per agent, per session, per message | Bring your own model; any LLM | Models and harnesses are plugins you swap | Any model; `hermes model` switches it |
| Where it runs | Our cloud, your VPC, or your own on-prem network | Local, Docker, a VM, or the cloud | Your own computer, or one shared Gateway | A $5 VPS, a GPU cluster, or serverless |

## Edit the files, push the branch, open the change request

`terminal`

```sh
git checkout -b tighten-triage
# edit agents/, skills/ or kortix.yaml
git commit -am "Tighten the triage prompt"
git push origin tighten-triage
kortix cr open --head tighten-triage --title "Tighten the triage prompt"
```

Source: https://kortix.com/docs/git

The last command files the branch for review, and the diff is what a reviewer reads.

## It depends on who runs the agent

Where an agent keeps its rules decides who can run it. A team whose work is coding agents, from one self-hosted console, fits OpenHands, which ships as Agent Canvas. One person who wants an assistant in the chat apps they already use, on their own hardware, fits OpenClaw and its single Gateway. A shell-first solo operator, who wants a terminal interface and a built-in cron schedule, fits Hermes Agent. A company that wants its agents, their skills and its own memory kept as ordinary files in a repository, with a person merging what a run produced, fits Kortix.

## Four tools, four places to look

A team that has decided to run autonomous agents on its own infrastructure usually arrives with a shortlist from an AI answer: OpenHands, OpenClaw, Hermes Agent, and the names around them. All four are open source, and all four start a run with nobody at the keyboard. The four resemble each other at first glance. One is a console for coding work. One is an assistant in your chat apps. One lives in a terminal. One is aimed at a company that wants the agent's rules under version control. The question that sorts them is where the rules live, what the memory holds and which systems a run can reach, and who signs off on what it produced. Those two facts decide whether the tool stays readable a year after the person who set it up has left.

## OpenHands: the work arrives as a coding task

OpenHands ships as Agent Canvas, and its own summary is a self-hosted console where coding agents and automations are run ([OpenHands](https://github.com/OpenHands/OpenHands)). The product is a front end for agents you may already run. It starts the OpenHands agent out of the box, and it can drive Claude Code, Codex, Gemini, Pi, OpenCode or any ACP-compatible agent across local, remote and cloud backends.

The work it organizes is coding work. An automation publishes a report to Slack, or splits a GitHub issue into tasks, on a schedule or a webhook event. Slack, GitHub and Linear are wired in. Backends, agent choices, automations and model settings live in the Agent Canvas frontend. A team can share one backend for code review while personal agents run on a laptop.

## OpenClaw: one assistant that meets you in your chats

OpenClaw is an open-source assistant that lives on one machine and answers in the chat apps you already use ([OpenClaw](https://github.com/openclaw/openclaw)). A single Gateway runs it, either for one person on a laptop or for a team that shares a deployment. Configuration is the only difference between the two. State, memory and credentials stay on your hardware. Models and harnesses are plugins you swap. There is no paid tier, hosted service or token.

The unit of work is a message. You write in Slack, Teams, Telegram, WhatsApp, Discord or iMessage, and the answer comes back in the same chat. For one person's assistant, or a small team sharing a channel, that shape fits well. The Gateway, the channels and the plugins make up the whole surface. Approval is a configured path rather than an absent one. Its documentation says configured policy is enforced in code, and that commands requiring approval must satisfy the applicable binding rules; it also notes that sandboxing is off by default ([OpenClaw](https://docs.openclaw.ai/start/why-openclaw)).

## Hermes Agent: an agent that grows in the terminal

Nous Research calls its project "the self-improving AI agent". It builds skills from experience, searches its own past sessions, and runs from a full terminal interface or from Telegram, Discord, Slack, WhatsApp, Signal and the CLI. One gateway process serves all of it ([Hermes Agent](https://github.com/NousResearch/hermes-agent)). `hermes model` switches models without code changes. A built-in cron scheduler delivers to any of those surfaces, and six terminal backends let it live on a $5 VPS or a GPU cluster.

This is the option for someone who works in a shell. The agent sits beside the commands, keeps notes between sessions, and answers in whichever chat app that person has open. Its configuration belongs to the gateway on the machine where it was installed. A team running agents on twelve machines keeps twelve setups in step.

## Kortix: the rules are files, and a person merges

For Kortix the answer is the bluntest of the four: the project is the repository. Agent files, skill files, memory and connector configuration sit in it as text, so editing one arrives as a diff on a branch, and the commit log says who changed what.

What a run may touch comes from the same place. "Rule each tool call allow, ask or block", and a rule can be narrowed to the arguments a call was given, so a release note passes while a refund waits for a person. A permission written down in the manifest is one a reviewer can read before the run rather than after it.

The last step is the one the other three leave to the operator. A session clones the repo and works on a new branch; when the agent is done it commits and pushes that branch, and a reviewer reads the diff. "A person with the project.gitops.merge permission reviews the change request and merges it." An agent that rewrites its own prompt proposes that edit like any other, so it lands beside the code the session touched.

The definitions behind these four tools are worth separating. [What autonomous AI agents are](/what-are-autonomous-ai-agents) turns the term into three testable parts. [Autonomous vs human in the loop](/autonomous-vs-human-in-the-loop) covers the three points where a person can hold a run. [Running an agent with nobody watching](/running-an-agent-with-nobody-watching) follows a session from its trigger to its change request.

## What buyers ask about open-source autonomous agents

### What are the best open-source autonomous AI agents?

The shortlist is Kortix, OpenHands, OpenClaw and Hermes Agent. OpenHands runs coding agents from a self-hosted control center, OpenClaw is an assistant on your own computer, Hermes Agent works from a terminal, and Kortix treats agents, skills and memory as versioned files in the project's own repository.

### Is there an open-source autonomous agent I can self-host?

Yes. All four run on hardware you control. Kortix runs on its cloud, your VPC or your on-prem network; OpenHands runs locally, in Docker, on a VM or in the cloud; OpenClaw runs on your own computer; Hermes Agent runs on a VPS or a GPU cluster.

### Can an open-source agent use any model?

Yes. Kortix is model-agnostic. Pick the model per agent, per session or per message, with your own provider key, a ChatGPT subscription or an OpenAI-compatible endpoint. OpenHands, OpenClaw and Hermes Agent each document bringing your own model too.

### How is Kortix different from OpenHands and OpenClaw?

Kortix puts the agent's rules, memory and connectors in a repository your team can read, and lands each run as a change request someone reviews and merges. OpenHands runs coding agents from a control center, and OpenClaw is an assistant that lives in the chat apps you already use.

## Put the rules in a repo, then add the trigger.

Start with the definition of autonomous agents, the three points where a person can stand, or a run that starts with nobody present.

[Try Kortix](https://kortix.com) · [Oversight levels](https://autonomousaiagentsguide.com/autonomous-vs-human-in-the-loop)