An open source agent built by the research group Nous Research, which turns finished tasks into reusable skills and remembers your preferences and project conventions across sessions.

Most AI assistants share one kind of amnesia. The code style, the project conventions, the traps you already stepped in, all explained repeatedly yesterday, and today a fresh session stares back waiting to be introduced again. Hermes Agent from Nous Research goes after exactly that. The claim is that it grows with you, and the selling point is not one dazzling answer. It is that the longer you use it, the more it resembles a colleague who already knows how you work.

The official description is plain: it is not a completion plugin bolted onto an editor, and not a chat shell wrapped around a single interface. It is a resident autonomous agent. Put it wherever you like and it takes root there, and from then on you can hand it work from a terminal or from the chat software you already use.

It writes down how the job got done

The most unusual part is a closed learning loop. When a task is complex enough, with the official reference being more than five tool calls, it reviews itself afterwards: why this worked, which traps it hit, what order to follow next time. The conclusion hardens into a markdown skill file stored locally, and when a similar task appears it opens the skill library and applies the existing procedure instead of reasoning from scratch.

Skills are not frozen one shot templates. When it finds a cheaper route, or discovers that the original approach dead ends, it patches the file and updates the entry itself. The official note is that this mechanism edits skill files rather than core code, so every bit of growth is readable and reviewable. Skills follow an open standard, can be exported and shared, and the community has contributed finished ones.

Change chat software and you do not have to be introduced again

A single gateway attaches more than twenty messaging platforms to one agent: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, email, SMS, DingTalk, Feishu, WeCom, WeChat, QQ bots, Yuanbao, Home Assistant, Microsoft Teams and Google Chat among them. The backend is always the same instance. Hand over half a job on your phone in Telegram, come back to the terminal and continue, and it remembers what you just said.

Along the same line, scheduled work is a built in capability. Say that every morning should summarise yesterday's commits, and it registers a fixed task that runs on its own and sends the result back to a chosen chat window or stores it as a local file. Watching something over the long term no longer requires building your own scheduler.

Memory lives in files you can open

What holds up the growing familiarity is a layered memory. The core is two markdown files: one records its own environment facts, project conventions and past traps, the other records your preferences, technical background and communication habits. Both have hard character limits so they cannot balloon. When a session starts, the system injects a frozen snapshot of both, and anything written mid session takes effect on the next round, which preserves the model side prefix cache and keeps the context from drifting suddenly.

For anything older it consults another store: every past session goes into a local SQLite database with a full text index, and with model summaries on top, questions like how did we handle this last month can be dug out. The official statement is that the software collects no telemetry and no usage data, that conversations, memory and skills stay on your own machine, and that which model provider to use is your decision, including bringing only your own key.

One window, several roles at once

When one assistant is not enough, roles are isolated: each role has its own configuration, memory, skills, credentials and chat history, can be pointed at a different model, and carries its own routine tasks. A built in mode gathers those roles into one roster, where they cooperate in a group chat and hand work to each other by mention. Work that can be split spawns isolated sub agents that run in parallel, and the main conversation assembles the result. It also speaks MCP to extend its tool surface, and separates being able to act from acting recklessly with layers of boundaries: approval for dangerous commands, container isolation, isolation between sessions.

What it can do right now

The licence raises no barrier: MIT open source, in both command line and desktop form, the desktop covering macOS and Windows, Linux and WSL2 going through the command line, with Nix, Android Termux and Docker also served. Where it runs is flexible too: locally, in Docker, over SSH, or on demand backends such as Daytona, Singularity and Modal, where the serverless option sleeps when idle and keeps cost very low.

It moves fast. The stable release at the time of writing is v0.21.6, dated 8 October 2026. The warning worth giving is that its advantages rest on being willing to spend time tuning it: it is command line first, and self hosting means servers, keys, updates and permissions are all yours to manage. It suits people who already enjoy that kind of work and who have a lot of repeated procedure worth capturing. For someone who only wants an occasional isolated question answered, the investment may not pay off.

Hand it the repetitive work a few times, and it remembers the rest for you.