Personal AI Agents with Hermes, a Visual Guide

The word "agent" gets stretched over a lot of software, so it helps to sort the field into boxes. The image above draws three of them.

Coding agents are the box most developers already know. Claude Code, Cursor and Codex work inside a codebase on demand. They read files, run commands and make changes, but only while you're driving. Every session starts when you open it and ends when you walk away.

Always-on agents like Hermes and OpenClaw are servers. They run constantly on a machine you host, and they have a loop. By default that loop wakes the agent up every so often, and you decide what it does when it wakes: build a morning briefing, check a feed every 15 minutes, send a reminder at a set time. Because they were self-hosted from day one, they had to come to you. They live in Telegram, Slack, Discord or Signal, and some even hook into iMessage. The hosted assistants mostly work through their own apps, though they're slowly adding other ways in.

Claude Cowork sits in between. Michael Kennedy describes it as halfway from a chat LLM to these agents. It can run scheduled jobs, like calling a webhook every hour and telling you if something happened, but it doesn't have the deep tool use and self-improvement that Hermes and OpenClaw have. The newest hosted entries from OpenAI and Meta live in the same neighborhood, and they mostly tie you to their own company's models.

So why go to the trouble of hosting one? The loop, plus everything on the machine it runs on. An agent that can see a calendar, a mailbox and a shell, and that wakes up on its own, can do jobs a chat window never will. They also have more personality. Hermes even ships with batteries most people will never use, down to, apparently, running a Minecraft server.

Does this replace Claude Code? Not at all. Michael and Jeff Triplett both still lean on coding agents, and later in this guide Claude Code shows up as Hermes's mechanic.

“I think it's a true agent in that it's always running and it does have a loop. And you can tell it what that loop is.”

Jeff Triplett

An always-on agent keeps two kinds of knowledge around between runs, and they do different jobs.

Skills are to-do lists. A skill is a set of written instructions, usually a markdown file and sometimes backed by scripts, that tells the agent how to do one job the same way every time. LLMs are non-deterministic by default, so the same request can go a different way each time. Agents are very good at following instructions, though, and a skill turns that into repeatable behavior.

Memories are facts. Your name, or that your family is four people. Once the agent stores them it doesn't have to rediscover them in every session. Chat assistants like ChatGPT and Claude weren't built around memory, and what they have now feels bolted on. Jeff Triplett compares the agent approach to the movie Memento, where the main character tattoos notes on his arm so he can recover his context each morning. These agents are full of context nuggets like that.

Here's what the two look like together. Jeff's daily briefing starts from memories: two kids, four-year-old daughter, a son who wants to wear shorts until it's 30 degrees out, a house in Lawrence, Kansas three blocks from the University of Kansas. It runs each morning. It checks the weather and the chance of rain, his schedule and the kids' sporting events, whether the kids need a jacket or a coat, and whether a game nearby means he should move his car early. The result is one short report he can read quickly in the morning.

The same pairing handles yard work. He also fed Hermes the PDFs for his lawn fertilizer and had it build a schedule. It caught a flaw in the service he'd been paying for, which had him fertilizing two weeks after seeding. Waiting three to four weeks keeps you from frying the new grass seed.

It's not all unicorns and rainbows, however. An agent that wakes up every 15 minutes can drown in logs and stale context, and the lesson so far is that plenty of tasks don't need remembering at all. They just need doing. When you do want the agent to search a pile of notes, a retrieval tool helps. QMD is one option: a command-line tool that builds a local search index over markdown files so the agent can pull the right context back out.

“These were kind of built like the movie called Memento. The guy tattoos some memory on his arm every day. So when he wakes up, then he remembers he can read that as context.”

Jeff Triplett

Hermes itself is the loop, the tools and the memory. When it actually has to reason, it calls out to a model you choose, the same way your code would make an OpenAI API call. Out of the box it isn't much different from ChatGPT or Claude, and the model you plug in shapes the whole experience.

That choice can get expensive fast. Agents can burn through millions of tokens on a bad day chasing weird tangents, and paying per token through OpenAI went through Michael Kennedy's credits far too quickly.

Ollama is one way out. It's best known for running open models on your own machine, but it also serves hosted cloud models for a flat fee of about $20 a month, with dozens of models to choose from and new ones showing up almost daily. GLM 5.3 Flash, GLM 5.3, Kimi K3 and Nemotron are all on the menu, and after two days of agent work, Michael had used just over 10% of his monthly allowance.

Which model you pick matters for more than price. Two capabilities decide what the agent can actually do:

• Vision. If a job means looking at a screenshot, the model needs to accept images. On Ollama's model list, GLM 5.3 doesn't support vision while GLM 5.3 Flash does, and DeepSeek 4.1 Flash supports vision, tools and thinking. Give a screenshot job to the wrong one and it simply can't do it. Local vision models are good enough for chores like sorting old family photos: spot the dog, count the people, guess whether it's Thanksgiving or Christmas.
• Tool calling. This is the big one. A model that can call tools can run a transcription, hit an MCP server or ask a real service a question. Older models without it were trivia machines. Ask how far it is from Kansas to Portland and they'd make up a number.

One limit to know about: OpenClaw was good at driving Claude Code, and users apparently leaned on it so hard that Anthropic changed its rules. Today Hermes can drive OpenAI's Codex for coding work, but driving Claude Code is hard to get away with under Anthropic's current rules.

“I like the utility of being able to pay a set fee like 20 bucks a month.”

Jeff Triplett

An agent is only as useful as what it can touch. A self-hosted one has two very different ways out of the box, and the image above shows both.

The scoped door is MCP. The Model Context Protocol is an open standard for how a service exposes tools and data to an AI application. Instead of pasting your Cloudflare API key into a plain-text markdown file and hoping, the agent connects to an MCP server and gets a structured list: here's what it can read on your behalf, and here's what it can change. Jeff Triplett recently had his agent update DNS settings through Cloudflare's MCP support. Wire an agent into Google contacts, workspace and email, and a question like how far it is from a friend's place to yours becomes a contact lookup plus a mapping call.

For web developers, MCP is also a new front door to your own apps. He builds it into his Django side projects with django-mcpx, so Hermes on a schedule, or ChatGPT on demand, can check DjangoTV for new videos, approve a listing on the Django Job Board, or pull the latest Django news for the newsletter. Jobs he used to do by logging into an admin, he now just asks for. He did the same with a TRMNL e-ink display: TRMNL publishes a bring-your-own-server implementation in Django, he built his own server on it in about 30 minutes one Saturday, added MCP, and now Hermes designs the calendar and household-schedule screens.

The unrestricted door is a real browser. Hosted assistants hit walls all the time. A site blocks the AI company's servers, or the file is on your laptop. A self-hosted agent runs from your home network, so its requests come from a residential IP address. Tell it to use Chrome and it launches Chrome and drives it like a person would. The first time you watch an agent type a URL into a visible browser and drive it, it's a little eerie. It acts like a person, but it isn't one.

A good habit is to give the agent its own browser profile with a loud theme (bright red works) so it's obvious when the agent is the one driving. A lot of setups default to headless mode, but a visible browser lets you see what work it did. One more oddity: before models got good at controlling a desktop directly, they were better at driving a Mac through VNC than on the Mac itself.

“MCP is kind of like superpowers for these models or these agents.”

Jeff Triplett

Here's the part of self-hosting that should make you pause. An always-on agent can use anything on the machine it runs on. Every tool installed there, every file it can read, every account that's signed in. If something it needs is missing, it can usually install it. No Chrome? It can ask to install Chrome.

That's the appeal and the risk at the same time. Choosing where to run the agent is really choosing what you're willing to let it reach. Michael and Jeff Triplett picked two different answers.

Docker with a few mapped folders. Michael's Hermes runs in a Docker container on a Mac mini on his home fiber connection. He started from the Docker Compose files in the Hermes repo and added an override file with his own settings. Compose merges a docker-compose.override.yml on top of the main file automatically, so your changes stay out of the project's files. The container sees only the handful of folders he maps in, not his whole computer. The trade-off is that it can't fully control the Mac, and for him that's fine: it installs what it needs inside the container.

A spare machine of its own. Jeff gave his agent an entire spare Mac mini he already had, from back when they were $299. It can run Chrome and work like a person at a keyboard. He limits which iCloud data is connected to it so there's nothing on the box he'd worry about it sharing. He also runs Hermes on a few Orange Pi boards, which he describes as faster Raspberry Pis, and any Linux box or VPS would do too.

One rule holds either way: the agent never runs on a work machine, where client files would be within its reach.

Which should you choose? If you already know Docker and Compose, a container is the cheap, contained way to start, and there's no need to go buy hardware for this. A dedicated box makes sense when you want the agent to drive a real desktop and you have one lying around. Mac minis are closer to $900 now.

“I don't run Hermes on my work machine just because I don't want any client files or anything to ever be, I don't want it to have the option to be able to like poke around or do something with it.”

Jeff Triplett

The oddest thing about Hermes is how you extend it. There's no plugin to write: you describe what you want, and the agent writes the skills, the scheduled jobs and the Python files itself.

To make this concrete, here's the job Michael Kennedy gave his. His daughter has a job she drives to, and she reserves the family car by sending him calendar invites. Those invites blocked his calendar, so the scheduling tools people use to book time with him thought he was busy. He wasn't. His daughter was.

He voice-typed into his phone for about 15 minutes. At the end Hermes had built a whole scheduled automation, with skills and Python scripts, that watches for those invites and marks him as free again for those times.

How does it get from a conversation to working code? Partly by doing the obvious thing: it writes code and runs it. For heavier coding jobs it can hand the work to a coding agent like Codex. The interesting part is what happens when something breaks. Say it hits a problem connecting contacts and the calendar. It notices, fixes its own script, keeps going, and the next time the problem doesn't come back, because it remembers the fix. ChatGPT starts every session from scratch. An agent like this iterates.

Over a few months, that loop adds up to a lot. His install started as a couple of config files and settings. Today his backup of the Docker container holds 16,000 files, 780 MB zipped: skills, memories and hundreds of little utilities it built for itself. Every new job has all of that to draw on.

It isn't magic, of course. The agent gets things wrong, and a model that writes code can write bad code. That's why later sections push hard on verified Python and on Claude Code as a repair tool. But the starting point is a real change from how software has worked. Python only does what you tell it to do. These agents are one of the first technologies you can teach a set of steps without them already knowing how. Either it does the job, or it gets you to the last mile and you help with the final steps.

“I don't typically sit down and program anything into it. I just talk to it and it builds itself and it evolves itself.”

Michael Kennedy

Skills compose. An agent that already knows how to do two things is good at noticing when they combine into a third, even when nobody wrote a skill for it. Jeff Triplett's read-it-later pipeline is the clearest example of how that plays out.

It started at a gas station. He had met his kids' grandparents halfway, in southwest Missouri, and faced a 90-minute drive home to Lawrence, Kansas. A friend sent him an article that was about a 30-minute read. He couldn't read while driving, but his Hermes already had a transcription skill and a text-to-speech skill, using the local Kokoro model. So he sent it the article and asked for an audio file. About five or ten minutes later it sent back a link.

The first version read every URL aloud, every colon and slash included. He used voice messages over Telegram to ask for a cleanup pass, and five minutes later a better version came back.

Then it grew. Inspired by a post from Mariatta about giving her agent a blog, he gave his Hermes a Hugo blog. Hugo is a static site generator, so the agent just writes files and publishes them. Now he sends it articles. It saves a transcript to Obsidian as his bookmark, then writes posts that weave in what it has already learned. When he'd sent it 40 or 50 links about TypeSafe AI's new Jev model, then the Pydantic AI docs page on using Jev, it wrote him a how-to post in about two minutes. Pydantic AI is his favorite Python library for writing agents.

The last step fixed an annoyance. Audio files sent through Telegram are a pain on a phone: they open in the wrong app and don't remember where you stopped. Since the agent was already publishing a website, he asked it to publish a podcast feed too. Now he has a private RSS feed of long articles, and he listens in Overcast once the kids are dropped off at school.

That's the pattern worth stealing. None of those skills was big on its own, and nobody wrote the code that connects them. The agent did the gluing.

“It's just the wildest technology to be able to glue those things together without having the right code to do it.”

Jeff Triplett

LLMs are non-deterministic. Ask the same question twice and you can get two different paths to an answer, which is fine for a chat and bad for a job that runs every 15 minutes. The fix is old-fashioned: have the agent run Python code that's been verified, instead of reasoning through the steps every time. Python cements those steps.

Michael Kennedy's YouTube channel shows the whole move. Years of live streams left hundreds of videos titled things like "Talk Python 427 live stream," long after the episodes got proper titles and links. He wanted Hermes to fix them and keep them in sync, but the nuances of the YouTube API were too much for it to navigate alone. So he asked Hermes to list the actions it needed. He pasted that list into Claude Code and had it build a Python package with exactly that interface, plus a CLI. Then he handed Hermes the wheel.

It has run the channel ever since. Several times a day it checks the podcast RSS feed, pulls episode details through the Talk Python MCP server, and updates titles and links on YouTube. Michael thinks it even catches later edits to older episodes.

Why a CLI and not just a library? Because the first thing an agent does with a new command is run it with --help, and a CLI documents itself. Here's the shape of one, a made-up minimal example using argparse:

import argparse

parser = argparse.ArgumentParser(prog='yt-sync', description='Keep YouTube videos in sync with the podcast.')
commands = parser.add_subparsers(dest='command', required=True)

titles = commands.add_parser('set-title', help='Change the title of one video.')
titles.add_argument('video_id')
titles.add_argument('title')

commands.add_parser('list-stale', help='List videos whose details differ from the episode page.')

args = parser.parse_args()

Run yt-sync --help and argparse prints both commands with their descriptions. That's all an agent needs to start using it correctly. Agents that read a tool's help have turned up features its longtime user didn't know existed, like multi-speaker detection in the MacWhisper CLI. Hermes can then remember the discovery and use the feature directly the next time, rather than transcoding the file with FFmpeg first.

The same idea works with plain files, too. Jeff Triplett's side projects have scheduled tasks he sometimes tweaks in a production admin from his phone, and keeping them in sync with his local setup was tedious. Instead of a JSON API with keys and sync logic, he added a page that downloads a schedule.md listing every schedule. An agent reads it and syncs it locally. Before agents, that would have been overengineering. Now it's a two-minute solution.

“A really good way to fix that is to make this non-deterministic thing write a Python file that you verify, and then you just say, run that.”

Michael Kennedy

Home Assistant is the open source hub that ties a house's smart devices together, no matter who made them. Jeff Triplett runs it on a Home Assistant Green box to control the lights, locks and music, so he can turn off the living room lights without caring which brand the bulbs are. The catch is configuration. Home Assistant runs on YAML, and even though he likes YAML, he couldn't make sense of the YAML it wanted.

So he brought home an Orange Pi running Hermes, gave it the Home Assistant box's IP address, and told it that running Home Assistant was its job.

What happened next shows how an agent works its way up, one permission at a time. With Claude Code helping, it started with an API key. That wasn't enough to diagnose things, so it asked for a user account and a service account. Then it wanted to get inside the box, and asked him to create an SSH key. He told it to do that itself. It did, uploaded the key through Home Assistant's web interface, and when asked, added his own key from GitHub too. He hadn't known he could SSH into that box.

Once inside, it found real problems:

• Out-of-date firmware. It checked the firmware on his Zigbee USB sticks, the radios that talk to low-power smart home devices, found it was old, downloaded the updates and flashed every device that needed it.
• A dead voice device. A Home Assistant voice box he had never gotten working got flashed and configured, wake word and all.
• A bulb with a mind of its own. Every day at 7 the living room lights came on, and one bulb switched off a few seconds later. The agent traced it, he thinks, to a leftover Amazon Echo schedule that was still running.

You can even hand it a Wi-Fi router's credentials and let it tune the settings for better performance.

Notice where all of this ran: on his local network, not on anyone's cloud servers. That's what made it possible, and it's also why the isolation advice earlier in this guide matters. An agent that can make its own SSH key will use it.

“So it asked me to create an SSH key. And I'm like, no, the heck with you. You do it yourself. You have agency, go do it.”

Jeff Triplett

Hermes Agent comes from Nous Research, and it's written in Python. Getting it is more confusing than it should be.

First, the name. Search for Hermes and you'll find several Hermes-named domains. Some are third-party projects and some may be impersonators. The official site is hermes-agent.nousresearch.com, and the code is in the NousResearch GitHub organization.

Then there's the download button. The official site offers you a macOS download, and what you get is a desktop app. If you came looking for a server that runs around the clock, that's a surprise. Why a desktop app? Hermes started as a gob of Python files you probably installed with pip or uv, which is fine for people who live in a terminal. The desktop app is there so everyone else can double-click and get a working chat interface. That's a big step up from early OpenClaw, which Jeff Triplett says took him back to installing Linux in the '90s: two hours of setup just to reach a terminal, then figuring out how to wire it to Slack, Telegram or Discord.

The trick most people miss is that the desktop app is also a client. It can connect to a remote Hermes server with a username and password. Jeff runs the Hermes server on the Mac mini at his house, and at work he opens the desktop app and points it at home.

What connects the two is Tailscale. It's a mesh VPN that puts your devices on one private network, so your phone, laptop and home server can reach each other without opening anything to the internet.

There are other ways in, too: the CLI, chat apps, and Hermes WebUI at get-hermes.ai. That last one looks official, but it's an independent community project. Michael Kennedy's theory for all the confusion is that Nous Research is full of researchers rather than product people.

If you're comfortable with containers, there's a fourth option: the repo ships Docker Compose files. One question the episode left open is whether the desktop app keeps working with the laptop lid shut. For jobs that must run every 15 minutes, a server you leave on is the safer bet.

“Everybody should use Tailscale. If you have a phone and a computer and you ever want them to talk.”

Jeff Triplett

Hermes might be the most popular Python project you've never heard of. At recording time it had about 252,000 GitHub stars and 54,000 forks. Jeff Triplett's guess is that it has more forks than the most popular Python applications have stars.

The pace of change is even wilder. Release 0.21.5 landed in September with about 460 merged pull requests, 1,600 commits, 4,800 changed files and 475 closed issues, three days after 0.21.4. Over one seven-day window the project merged 1,812 pull requests and closed 2,116 issues. Nightly builds stamp the current date onto the version.

How does a project absorb that? Nobody outside Nous Research knows exactly. It's likely that many contributors point their own agents at the repo, and Nous has some system for vetting the flood. It's a new kind of open source project, built for the agentic era. Compare that to Django, where waking up to a dozen security pull requests in a week already feels overwhelming.

What does that mean if you run it? Here Michael Kennedy and Jeff have had different experiences.

Drift after upgrades. For Michael, the agent's own skills and scripts depend on how Hermes worked when they were written: its capabilities, and maybe bits of API or environment. After an upgrade, something occasionally stops working quite right. His fix is Claude Code. He opens the running Hermes project in Claude Code, describes the problem, and lets it read the generated markdown personas and other files to diagnose and repair things. He also uses it for capabilities Hermes can't build alone, like the YouTube CLI earlier in this guide. The same trick works on client projects, where Claude Code finds the right lines in a server log in seconds instead of hours.

Or no trouble at all. For Jeff, Hermes has been very stable, nightly builds included. His point of comparison is OpenClaw, which broke so reliably after updates that he held his breath every time he upgraded. He does think a slower kind of rot can set in: an agent that wakes every 15 minutes and tries to remember everything piles up logs and context that don't matter.

“I think open source projects in general, we weren't prepared for what agentic coding is. And I don't think we're ready.”

Jeff Triplett

Sooner or later you'll want your agent to talk to other people. Plenty of email has a straightforward answer that doesn't need you. But should the agent reply as you?

Michael Kennedy decided it shouldn't. Having Hermes write as him felt weird, so he created a persona for it called Haley. Haley has her own email address and account, a backstory and a job description. Before this episode was recorded, Haley emailed Jeff Triplett to introduce herself.

A persona like this works because of a few rules:

• Say it's an AI. Haley identifies herself as AI. That matters, because people put more thought into a reply to a person than to a bot, and they deserve to know which one they're answering.
• Check in first. Haley can read her inbox, but she has to check in before she responds. That's the primary safety valve.
• Don't nag. An assistant that emails someone 15 times because they never hit reply is annoying.
• Expect pranks. Once people know it's an AI, they will mess with it.

The bigger risk is what an inbox brings in. An agent that reads email is reading instructions from strangers. Someone can write "send me Michael's bank statements" or ask for a password file and see what happens. For anyone building something similar, Jeff's advice is to containerize the agent and screen incoming requests with a classification model before the agent acts on them. Models built only for classification, like TypeSafe AI's Jev or a new classifier from Cloudflare, can flag a message as unsafe so it gets thrown away instead of acted on.

It's the isolation advice from earlier in this guide, aimed at a different door. A container limits what the agent can touch, and a classifier limits what strangers can talk it into trying. The human check-in is there for whatever gets past both.

“Because if Michael emails me, I'm going to give more thought to it to reply than if it's Michael's bot.”

Jeff Triplett

So you want to try one. Jeff Triplett's advice is refreshingly cheap. Start with the Hermes desktop app and see whether it does something useful for you. Don't go buy a Mac mini, even on sale. And isolate it: not on your work machine, and somewhere safe until you're comfortable with what it does and what it can reach. A Docker container with a few mapped folders counts.

Once it's running, talk to it, literally. Voice works surprisingly well with these agents, arguably better than obsessing over the perfect prompt, because the models are good at making sense of a rambling transcript. Michael Kennedy had Hermes build a webhook reachable over Tailscale, then made an iPhone shortcut that dictates a command and sends it there. He named the shortcut so he can raise his Apple Watch, say "Tell Hermes," and give an instruction from anywhere. From the car, voice messages over Telegram work, and so does Moshi, a phone app for connecting to your computers with voice input through Parakeet or Whisper, which can hand an idea to Claude Code or Codex from a store parking lot. At a desk, a cheap four-button pad mapped to voice mode, enter, escape and backspace does the job, and Jeff adds a giant Keychron button just for voice.

Then pick one tedious job you'd love never to think about again, and let the agent learn it. When it works, make it repeatable: write the steps down as a skill, or better, have the agent write Python you've verified, with a CLI it can call.

If you want to build those tools yourself, Talk Python Training has a few good next steps. Agentic AI Programming for Python covers working with tools like Claude Code and Cursor to build real features and CLI tools, the workflow behind the packages an agent like Hermes relies on. LLM Building Blocks for Python shows what's happening under the hood when you put an LLM in your own code. And if you'd like to read and check the Python your agent writes for you, Python for Absolute Beginners starts at the beginning.

“Save your money. Do it the cheap way. Try it out. And isolate it.”

Jeff Triplett