TL;DR: A self-hosted AI agent is an assistant that runs on your own machine or server and can take actions, not just answer questions. Six open-source agents are worth a look in 2026: OpenClaw for chat apps, Hermes Agent for desktop and terminal work, OpenHands for code, Paperclip for teams, Goose for extensions and Dify for a shared internal assistant. All six are free, all six speak MCP, and none of them makes the model free.
What a self-hosted agent actually is
Three different things get called "self-hosted AI", and mixing them up is why so many guides are useless.
The model runs somewhere. That is Ollama, vLLM or llama.cpp: a model file on your hardware, answering prompts.
The agent runs somewhere. That is the orchestration layer: the thing that decides which tool to call, remembers what happened last time, and turns a request like "clear my inbox" into a series of actions.
The actions touch real accounts. Mail, calendar, files, a repository, a browser. This is where an agent stops being a chatbot and starts being a permission decision.
An agent can be fully self-hosted while its model is a paid API, and that is the most common setup. You own the orchestration, the memory and the data flow, and you rent the intelligence by the token. A fully local stack, model included, is a different project with different hardware requirements.
The six, side by side
| Agent | Licence | Where it runs | Strongest at | The catch |
|---|---|---|---|---|
| OpenClaw | MIT | Your machine or VPS | assistant inside WhatsApp, Telegram and your inbox | you pay for the model, and the project moves fast |
| Hermes Agent | MIT | Desktop app (Windows, macOS, Linux), terminal, messaging gateway | desktop and terminal work, with the same agent reachable from chat apps | general-purpose, so nothing is pre-wired for your inbox |
| OpenHands | MIT | Sandbox | software engineering tasks in a repository | developer only |
| Paperclip | MIT | Self-hosted | agent teams with budgets and audit trails | heavier to set up |
| Goose | Apache 2.0 | Desktop app, CLI, API | automation assembled from extensions | you assemble the workflow yourself |
| Dify | modified Apache | Self-hosted server | visual apps, agents and retrieval over your documents | licence has conditions |
What all six have in common
Every agent here accepts MCP servers, so a tool integration you build or install for one is not wasted when you switch. OpenClaw exposes it through an MCP relay plugin, Goose treats extensions as MCP servers, Paperclip runs a governed MCP tool gateway, and Hermes, OpenHands and Dify connect to MCP servers directly.
They also share the basics: free licences, self-hosting, and the ability to point at whichever model you choose. The differences are surface, permissions and how much the tool decides for you.
Where each one fits
OpenClaw: the one that lives in your chats
You install it on your own machine, connect WhatsApp or Telegram, and talk to it where you already talk to people. It reads your inbox, drafts and sends mail, manages your calendar and checks you in for flights. Memory persists between conversations, so it carries context between sessions instead of starting cold.
The version to know about is 2026.11.1 on npm, and the install brings Node.js with it. What you supply is the model key. That is also the honest catch: a busy assistant on a frontier model is a real monthly bill, and an agent that can send email on your behalf deserves a secondary account and a short leash at the start.
Hermes Agent: the one with a desktop app and a terminal
Hermes Agent runs three ways: an official desktop app for Windows, macOS and Linux, a terminal interface, and a messaging gateway that connects the same agent to Telegram, Discord, Slack, WhatsApp and Signal. That is more entry points than most tools here, and it means the "where do I talk to it" question has several answers rather than one.
Underneath it has tools, MCP support, persistent memory and a skill system that saves what it learns as reusable procedures. It is MIT licensed and from Nous Research.
The honest catch is the opposite of a limit on reach: it is general purpose. OpenClaw ships opinionated integrations for inbox, email and calendar; Hermes gives you the agent and the tools, and you wire the workflows yourself. The terminal interface also assumes you are comfortable in a shell, though the desktop app does not.
OpenHands: the one for code
A software engineering agent that runs in a sandbox, reads a repository and proposes changes as a diff you review. It is the most focused tool here, and the one with the clearest quality bar: the work either builds or it does not. It has nothing to say about your calendar, and it is not trying to.
Paperclip: the one for teams and budgets
Built around role-based agent teams with budget controls and audit trails, plus a governed MCP tool gateway so every tool call has a policy attached. The moment more than one person or more than one agent shares a setup, "who spent that" and "who allowed that" become the important questions, and Paperclip is designed around answering both. It takes longer to stand up than the single-user tools.
Goose: the one that extends sideways
Block's local agent, shipped as a desktop app, a CLI and an API. Its extensions are MCP servers, which means the catalogue is effectively the MCP ecosystem rather than a curated list, and anything you wire up for Goose tends to work elsewhere. It is a toolkit: you assemble the workflow yourself, which is either the appeal or the reason to pick something more opinionated.
Dify: the one for a shared assistant
A visual builder for LLM applications: agents, workflows, retrieval over your own documents, MCP tools, and a web interface your colleagues can use without touching a terminal. It is the right shape when the goal is one internal assistant for ten people rather than a personal agent for one. Read the licence before you plan on it, because Dify uses a modified Apache licence with conditions rather than plain open source.
What self-hosting an agent actually costs
The software is free in every case above. The bill arrives from three other directions.
Tokens. Every conversation costs model time. An API model is charged per token, and an agent uses far more tokens than a chatbot because it plans, calls tools and checks results. Set a spending cap on day one, not after the first surprise invoice.
Hardware, if the model is local. Running the model yourself removes the token bill and replaces it with VRAM. A small model runs on a modest machine, slowly. A good one wants a serious GPU. There is no honest way to quote a single figure here, because the answer depends on which model you pick and how long your prompts are.
Your time. Updates, permissions, backups and the occasional broken upgrade. This is the real cost of self-hosting anything, and it is the one most guides leave out.
Where self-hosting falls short, honestly
You are the sysadmin. There is no support contract, no status page, and nobody to escalate to when an upgrade breaks at 11pm.
The security surface is larger than it looks. An agent with mail access can send mail. An agent with shell access can run commands. Scope the accounts, run it on a machine that is not your main workstation if you can, and revoke access when you stop experimenting.
The model is only as good as what you point it at. A self-hosted agent on a small local model is a different product from the same agent on a frontier model, and the comparison tables never say so.
Mobile is solved unevenly. OpenClaw lives inside chat apps you already have on your phone, and Hermes Agent reaches the same chat apps through its gateway. The desktop-only tools need a web interface or a remote machine to be useful away from your desk.
How to get started
- Pick the surface first, not the tool. Chat apps point at OpenClaw, a desktop app or terminal points at Hermes Agent, a repository points at OpenHands.
- Run it somewhere that stays awake. A small VPS is enough for the agent itself when the model is an API. An old laptop works too, until the lid closes.
- Start with a throwaway account. Point it at a secondary mailbox before you point it at the one your bank emails.
- Cap the spend before the first conversation. Every provider has a budget setting. Use it.
- Keep notes. These projects ship quickly. Write down the version you installed and the config that worked, because an update in three months will not remember for you.
Who is behind them
OpenClaw is MIT licensed and stewarded by an independent 501(c)(3), with no hosted tier to upsell. Hermes Agent is MIT, from Nous Research. OpenHands is MIT, from All Hands AI. Goose is Apache 2.0, from Block. Paperclip is MIT, from Paperclip AI. Dify is a modified Apache licence with conditions, from LangGenius.
That matters more than it sounds. A single-vendor agent can change licence or direction in a release. A foundation-stewarded or corporate-backed one has a different set of incentives, and neither is automatically better. Read the licence file, not the badge on the README.
Questions people actually ask
Do I need a GPU? Only if the model runs locally. An agent pointed at an API needs no GPU at all, and that is the cheaper way to start.
Can it work without any API key? Yes, if you run the model yourself through Ollama or a similar runner. The agent still needs a model endpoint, it just does not need a paid one.
Is it safe to give an agent my email? That depends entirely on what you grant it. Start with a secondary account, grant the narrowest scope that does the job, and revoke it when you stop.
What is the difference between an agent and a chatbot? A chatbot answers. An agent decides what to do, calls tools, checks the result and remembers it next time. The difference shows up the first time it sends an email without asking.
Can I run one on a Raspberry Pi? The agent itself, often yes, and Docker makes it easy. The model is the limit: a Pi orchestrates fine but will not run a good LLM.
Which one is closest to ChatGPT? On the surface, OpenClaw, because it lives in chat apps. On the output, none of them, because ChatGPT has browsing, image generation and a hosted model behind it that these agents have to be pointed at.
Do they all support MCP? Yes. That is why the choice comes down to surface and permissions rather than integrations. A tool you connect today can usually follow you to a different agent tomorrow.
The Bottom Line
Self-hosting an agent buys you control, memory and the ability to point it at your own accounts, for the price of a model bill and your own maintenance time. Of the six, OpenClaw is the one to try if you want an assistant where you already chat, Hermes Agent if you want a desktop app, a terminal and chat access behind one agent, OpenHands if the job is code, and Dify if the goal is one shared assistant for a team.
The software is free. Plan for the other three costs, and start with a throwaway account.
Last checked: November 2026. Licences read from each project's repository rather than the GitHub summary, platform and MCP support taken from each project's own README and documentation pages, and the version from npm. This compares documented scope and licence terms, not benchmark results: I have not run the six against an identical task suite, and anyone who claims a winner without doing that is guessing.
Related reading: How to put every free LLM tier behind one OpenAI-compatible API, which solves the model side of the same problem without running six different clients.
Browse more: Self Hosted and AI Writing Assistants & Chatbots.