The Machine That Learns to Forget What It No Longer Needs

There is a particular kind of software announcement that arrives in the world the way a new acquaintance arrives at a dinner party: with enormous confidence, a firm handshake, and the implicit suggestion that everyone in the room has been waiting for exactly this. Most such announcements, of course, are forgotten before the dessert arrives. A few, very few, turn out to be the person you are still talking to at two in the morning when everyone else has gone home and the conversation has turned, somehow, to the nature of memory itself.

Hermes Agent Desktop is, I would argue, the latter kind of arrival. Not because it is flawless and not because it solves everything, but because it asks, quietly and with genuine seriousness, a question that most software has been too polite or too shallow to ask: what if the tool you use every day actually got better at being used by you, specifically, over time?

The answer, it turns out, is both more practical and more strange than it first appears.

Nous Research and the Art of Making Something That Grows

To understand Hermes Agent Desktop, you must first understand what Hermes Agent is, which requires a brief detour into the philosophy of Nous Research, which is itself a brief detour into the peculiar moment we are living through, a moment in which AI laboratories have begun releasing tools so fast that the act of keeping up has itself become a kind of profession.

Nous Research launched Hermes Agent on February 25, 2026. By June, it had accumulated more than 180,000 GitHub stars, a figure that, in open-source terms, is less a metric and more a kind of referendum. The question on the ballot was simple: does this do something different? The community's answer, delivered through the blunt instrument of a star rating, was an emphatic yes.

What Hermes Agent does differently is almost embarrassingly straightforward to describe, even as it is genuinely difficult to appreciate without using it. Most AI agents are stateless. Every conversation begins from zero. The agent has no memory of the task it completed for you yesterday, no record of the approach that worked and the one that did not, no accumulated intuition about the domain of problems you most frequently throw at it. It is a brilliant dinner guest who forgets your name between visits and must be reintroduced every time.

Hermes is the dinner guest who, by the third visit, has already learned how you take your coffee.

After each completed task, the agent runs what Nous Research calls a closed learning loop. It evaluates whether the outcome succeeded, extracts the reasoning patterns that made it work, and stores them as skill files: plain Markdown documents, entirely human-readable. The next time it encounters a structurally similar problem, it reaches for the relevant skill rather than reasoning from scratch. Independent benchmarks by TokenMix in April 2026 confirmed the internal claim: agents with more than twenty self-generated skills complete comparable future tasks approximately forty percent faster, measured in both token consumption and elapsed time.

The qualifier, which Nous Research states plainly and which I respect them for stating, is that this improvement is domain-specific. A skill learned from database schema design does not transfer to copywriting. The agent does not generalise across domains with anything approaching magic. What it does is accumulate competence in the areas where you actually use it, which is, if you think about it, also how expertise works in humans. We do not become universally better from practice; we become better at the things we practice.

This is not a limitation to apologise for. It is the design.

A Desktop App for People Who Have Better Things to Do Than Learn a Terminal

Hermes Agent has been available since February, but until June 2, 2026, using it with anything resembling a graphical interface required finding a third-party wrapper, installing it separately, and accepting that the person who built it might abandon it next week. Nous Research documented the best community-built options. They praised several. They built none of them, until now.

Hermes Desktop, released at v0.15.2 as a public preview, is the first GUI that comes from the same team that builds the agent. It runs natively on macOS, Windows, and Linux. It shares the same configuration, the same API keys, the same sessions, the same skills, and the same memory as the CLI version. It is not a separate product or a lightweight clone. It is, to use the official language, "the same agent you get from the CLI and the gateway, driven through a modern and thoughtfully designed UI."

This matters more than it might seem. The history of developer tools is littered with graphical wrappers that quietly diverge from their command-line counterparts, that surface a curated subset of features, that update on a different cadence, that make trade-offs the original authors would not have made. Hermes Desktop is an explicit rejection of this pattern. A session started in the desktop app can be resumed in the terminal. A skill created through a terminal session is available immediately in the desktop interface. The state is unified because it lives in the same files on your disk.

The interface itself is organised around a chat-first window with a left sidebar for navigation. At its centre is a streaming conversation view with live tool activity: you watch the agent think, in real time, as structured summaries of its tool calls scroll past. To the right, a preview rail renders web pages, files, and tool outputs side by side while the conversation continues. Files can be dragged directly into the chat area. The composer remembers your previous prompts and lets you cycle through them with the arrow keys. The status bar at the bottom exposes an inline model picker and a per-session YOLO toggle. That toggle is Hermes's somewhat alarming name for the mode in which the agent bypasses confirmation prompts for potentially dangerous commands, and it is, in fairness, labelled with sufficient directness that only the incautious should be surprised by the consequences.

The management panes are where the app earns its keep for users who would otherwise never open a terminal at all. Skills can be browsed, installed, and managed through a real interface. Scheduled jobs are configured through a cron builder that accepts natural-language input. Provider credentials are managed through a dedicated settings pane with an accounts interface that covers every major model provider: Anthropic, OpenAI, OpenRouter, xAI Grok (with OAuth), and a growing list of others. The first-run onboarding has been redesigned, and there is now a Choose provider later option for users who wish to explore the interface before committing to an API key.

Sixteen messaging gateways are configured from the same settings surface: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, email via IMAP and SMTP, SMS via Twilio and Vonage, iMessage through BlueBubbles, and a list of platforms that suggests Nous Research has thought carefully about where people actually live their digital lives. One agent, one memory, every surface. Start a conversation in the desktop app; continue it on Telegram from your phone; have the results delivered to your team on Slack. The session is the same throughout because the memory is the same throughout.

This is, quietly, the genuinely new thing. Not the interface (interfaces are negotiable) but the persistence. The idea that the tool you talk to on your desktop and the tool that messages you on your phone are not two tools pretending to be one, but one tool with many faces.

The Kanban: Or, What Happens When Your AI Gets a Staff

There is a moment in the growth of any serious organisation (a production team, a newspaper) when the single brilliant generalist who could handle everything becomes a bottleneck. Not because they have become worse, but because the work has grown faster than one person can process it. The solution, historically, is specialisation and delegation, coordinated through some system of shared visibility: a board on the wall, a shared document, a project management tool, that lets everyone know what is being worked on, what is waiting, and what is done.

Hermes Kanban is that board, for AI agents and the Human In The Loop.

Released as a major feature in v0.13.0 (codenamed Tenacity, a choice of name that will reveal itself as deliberate) on May 7, 2026, and substantially expanded in v0.15 on May 28, the Kanban system is a durable, SQLite-backed task board shared across all of a user's Hermes profiles. Each profile is a named agent configuration with its own identity, memory, and area of specialisation. Where the older delegate_task mechanism worked like a function call (one agent spawning a temporary anonymous subagent to complete a sub-task and return a result), Kanban works like a work queue, where every task is a persistent row in a database that any profile can read, write, claim, comment on, and hand off.

The distinction is not merely architectural. It is the difference between whispering something to a colleague and writing it on the shared board. The whisper disappears when the conversation ends. The board entry survives restarts, crashes, and the passage of time. Anyone who needs to know what happened can find out by reading the row.

A task on the Hermes Kanban moves through a defined set of states: triage, todo, ready, running, blocked, done, archived. The dispatcher is a long-lived loop that runs inside the Hermes gateway and ticks by default every sixty seconds, managing transitions. It reclaims stale claims from workers that have stopped responding. It detects crashed worker processes by checking whether the PID is still alive. It promotes tasks from "todo" to "ready" when all their upstream dependencies reach "done." It spawns the assigned profile as a new OS process when a task becomes ready to run. It has, in short, the institutional memory and the tireless vigilance that most project management systems demand of humans and then fail to sustain.

The heartbeat mechanism deserves particular attention. Each running worker periodically signals to the dispatcher that it is still alive and making progress. If those signals stop (because the worker crashed, because the model entered an infinite reasoning loop, because the API call timed out at an inopportune moment), the dispatcher reclaims the task, marks the previous run as failed, and schedules a retry. The number of retries before a task is automatically moved to blocked and flagged for human review is configurable per task. This is what Nous Research means by Tenacity: the system does not give up when something goes wrong; it tries again, records what happened, and eventually escalates to a human only when it has exhausted the options available to it.

The zombie detection mechanism is exactly what it sounds like: the dispatcher checks for workers that are no longer running, whose OS process has terminated without properly completing or blocking their assigned task, and reclaims them. In a system that might run dozens of parallel workers across a long weekend of unattended operation, the difference between a system that detects and recovers from zombie processes and one that does not is the difference between waking up on Monday to find the work done and waking up to find it silently abandoned halfway through.

What the Board Looks Like in Practice

Consider the scenario that the official documentation uses to explain the system's power, which is a useful illustration precisely because it is not exotic. You have three specialised Hermes profiles: a transcriber, a translator, and a copywriter. You have a pile of audio recordings from a multilingual conference. You want all three workers pulling tasks in parallel, with the copywriter's tasks automatically becoming available only after the transcriber and translator have completed their prerequisite work, and with visible progress throughout.

You create the tasks, establish the dependency links, start the dispatcher, and walk away. The transcriber begins working through the audio files, appending its output to each task's comment thread. The translator picks up completed transcription tasks as they become ready, writing its translations to the same thread. The copywriter's tasks remain in todo until the translations they depend on reach done, at which point the dispatcher automatically promotes them to ready, and the copywriter spawns, reads the full comment history of its task (including all the upstream work), and begins drafting.

If the translator's API provider returns a rate limit error, the task moves to "blocked" with a note explaining why. The retry budget prevents the dispatcher from hammering the same failed endpoint in a loop. A human can inspect the blocked task, unblock it once the rate limit has cleared, and the system picks up exactly where it left off.

The human-in-the-loop capability is not bolted on as an afterthought. The /kanban command is explicitly exempted from the guard that normally queues messages while an agent is mid-turn. Because the board lives in its own SQLite database, independent of any running agent's state, a user can comment on a task, unblock a stalled worker, or redirect an assignee from their phone while the rest of the board continues running. The intervention lands on the task thread and takes effect on the next dispatcher tick, without interrupting the workers that are currently running and making progress.

The trash drop zone in the dashboard (drag a card to delete it, with a confirmation prompt) is the kind of small UX detail that reveals whether a feature has been thought through to the last ten percent. The scheduled task capability, which lets you set a scheduled_at timestamp on any task and have the dispatcher simply skip it until that moment arrives, means that the Kanban board can serve as a temporal orchestration layer for work that needs to happen at specific times: a nightly backup audit, a weekly competitive analysis, a monthly report, across a fleet of specialised agents that accumulate knowledge of their domains over weeks and months.

The Key Thing Inside

There is, in all of this, something that the documentation discusses in careful technical language but that deserves to be said more directly. Hermes Agent Desktop (and particularly its Kanban system) represents a meaningful shift in what it means to use an AI tool, not because the technology is magic, but because the architecture takes seriously a premise that most commercial AI products have been slow to embrace: that the relationship between a person and an AI agent is more valuable the longer it persists, and that value should be stored in a form that belongs to the user, not the vendor.

The skill files are Markdown. The session history is SQLite. The kanban board is SQLite. The memory is files on your disk. All of it is readable, editable, auditable, and yours. The agent runs locally or against any OpenAI-compatible endpoint you choose. Nothing is locked to Nous Research's infrastructure. The Nous Portal provides managed access to a curated model set for subscribers who want the convenience, but the underlying agent (its memory, its skills, its kanban board, its accumulated competence) belongs entirely to the person running it.

This is not how most AI products are designed. Most AI products are designed to make your data and your usage history as sticky as possible, to accumulate your preferences and your context inside a system you cannot export, cannot inspect, and cannot take with you when you leave. Hermes is, in this respect, more like a well-designed piece of furniture than a subscription service: it improves with use, it fits your specific habits over time, and you can move it if you decide to live somewhere else.

Whether this approach can sustain a business is a question I will leave to people with spreadsheets. Whether it represents a more honest way to build tools for the people who use them is a question I am prepared to answer.

It does.

A Note on What Remains Unfinished

It would be incomplete, and insufficiently honest, to conclude without acknowledging what Hermes Agent Desktop is not yet.

The self-improving skill system is domain-specific in ways that can surprise new users. The improvement that accrues in one area of work does not transfer to another area of work, and the agent has no visibility into this limitation. It does not tell you when it is outside the range of its accumulated skills and would benefit from more explicit guidance. The skill files are human-readable, but the process by which the agent decides to preserve or modify a skill has no explainability interface. The Kanban system's auto-decomposition and swarm topology features were still pending final merge at the time of the v0.15 desktop release. And the desktop app itself is a public preview at v0.15.2, which is the version's way of saying: we believe in this enough to ship it, but please do not run your critical production workloads exclusively on it just yet.

These are real limitations, noted not to dismiss the work but because software that aspires to grow with its users should be held to the standard of transparency it implicitly promises.

What Hermes Agent Desktop has built, even in this state, is a foundation that takes the relationship between tool and user more seriously than most. It remembers. It learns. It coordinates. It survives restarts and crashes and rate limits and zombie processes. It does all of this while keeping your data on your disk and your options open.

The machine that grows with you, the tagline reads.

It is a claim ambitious enough to be wrong in a hundred ways. It is also, based on the evidence available, substantially true. And in the current landscape of AI tools (a landscape crowded with announcements that promise transformation and deliver convenience) substantially true is, quietly, a remarkable achievement.

Hermes Agent Desktop v0.15.2 is available for macOS, Windows, and Linux. It is open-source under the MIT license.