Build your own Instinct, or Muse, with Hermes Agent

September 2026 was the month the personal assistant came back. Meta launched Muse, which “keeps working after people close the app, and comes back when something changes or when it needs approval,” and “remembers what matters to a person, so it can make suggestions unprompted.” A few weeks earlier, Instinct appeared in private beta with a sharper pitch: an assistant “following up on threads you’ve dropped, proactively calling or texting you.”

Strip the branding and both products are the same three things: a memory of you, a presence in the apps you already message from, and a clock that lets the assistant speak first. None of that is proprietary. You can build it this weekend with Hermes Agent.

What Hermes Agent is

Hermes Agent is Nous Research’s open-source agent, MIT-licensed, and shipping a release every few days (v0.21.5 landed on 24 September 2026). Nous describes it as “the self-improving AI agent” with “a built-in learning loop”: it writes its own notes, turns hard-won workflows into reusable skills, and searches its own past conversations.

The detail that matters for this essay is where it runs. Hermes is not a library you build an agent out of; it’s a finished agent you run as a background process. In Nous’s words, “Run it on a $5 VPS, a GPU cluster, or serverless infrastructure that costs nearly nothing when idle. It’s not tied to your laptop — talk to it from Telegram while it works on a cloud VM.” It works with whichever model you point it at: Nous Portal, OpenRouter, OpenAI, Anthropic or your own endpoint.

Ingredient one: it remembers you

Hermes keeps two small files. MEMORY.md holds the agent’s own notes (environment facts, conventions, things it learned), capped at 2,200 characters. USER.md holds its picture of you (preferences, communication style, expectations), capped at 1,375. Both are injected at the start of every session, and the agent edits them itself with a memory tool. When a file fills up, the write fails and the agent has to decide what to drop. It never silently forgets.

The docs draw a line I like: “memory stores small durable facts that should always be in context, while skills store longer procedures that should load only when relevant.” If you want a deeper model of the person, Hermes can hand user modelling to Honcho, which “maintains a running model of who the user is” by reasoning about conversations after they happen.

Ingredient two: it lives where you message

One gateway process connects Hermes to Telegram, Discord, Slack, WhatsApp, Signal, SMS, email, iMessage (through BlueBubbles) and more than a dozen others. By default “the gateway denies all users who are not in an allowlist or paired via DM,” which matters for a bot that can run commands on a computer.

Ingredient three: it speaks first

This is the part that makes Muse and Instinct feel different from a chatbot, and Hermes has three ways to do it:

• On a schedule. Cron jobs run in a fresh session and deliver the result to your chat. They still load MEMORY.md and USER.md, so a morning briefing knows who it is talking to.
• On a change. A job can run a cheap script first and only wake the model if something moved; the script answers {"wakeAgent": false} otherwise, and nothing is sent. Webhooks can trigger runs from outside events.
• On idle. A heartbeat wakes an idle conversation on a timer, with its full context. The agent is told to stay quiet when nothing has changed, and a silent turn sends nothing. That is the difference between ambient and annoying.

There is one real difference from the commercial products. Instinct decides when to reach out. With Hermes, you decide: you write the schedule, the trigger or the thing to watch. Nothing infers on its own that now would be a good moment.

Mapping the products to the parts

Building it

The install is one line on Linux, macOS or WSL2, straight from the README:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Then pick a model and connect a chat app. hermes setup runs the whole wizard; the individual steps are:

hermes model        # Choose your LLM provider and model
hermes gateway setup
hermes gateway start

Send your bot a message and use /sethome in that chat so scheduled jobs know where to deliver. To keep it running after you log out, the docs install the gateway as a service:

hermes gateway install     # Install as a user service

Give it a personality. SOUL.md in ~/.hermes/ is “the first thing in the system prompt and defines who the agent is.” This is where your version of Muse or Instinct gets its manners: how brief to be, when to interrupt you, what never to do without asking.

Make it speak first. The docs’ own example of a scheduled job is a single sentence you type into the chat:

Every morning at 9am, check Hacker News for AI news and send me a summary on Telegram.

For follow-ups inside a conversation, a heartbeat takes an interval and an instruction, as in the docs’ example:

/heartbeat every 10m Check the deployment and report meaningful changes

Decide how much it can learn on its own. If you want to approve what it remembers about you, the memory settings have a switch for exactly that:

memory:
  memory_enabled: true
  user_profile_enabled: true
  memory_char_limit: 2200   # ~800 tokens
  user_char_limit: 1375     # ~500 tokens
  write_approval: false     # false = write freely (default) | true = require approval

How I run mine

My own agent is deliberately boring. It is stock Hermes on a small Linux server, running as a systemd service, with no changes to Hermes’ code: everything it does comes from configuration, a short SOUL.md, a handful of skills and five scheduled jobs. It talks to me on WhatsApp only, through an allowlisted group, and it runs on GLM through an OpenAI-compatible endpoint, which is a good test of the “any model” claim.

The scheduled jobs all follow the same pattern: a plain script gathers the data (the weather, the day’s Hacker News, a ledger of what it has already covered), a skill describes the procedure, a short prompt kicks it off, and the result lands in the chat. The morning brief, a daily explainer on one idea, a shortlist of topics I might write about, a side-project idea. One job uses no model at all: a script that only speaks up when a session has grown too long.

What it doesn’t do is reach out on its own. I left heartbeats off on purpose. The note in my own design doc says: copy the proactivity, don’t copy the trust model. An agent that can run commands and message you unprompted should earn that, one narrow job at a time.

What you trade

Muse and Instinct are polished, and Hermes is a toolkit you assemble. In return, you choose where your data lives. Muse keeps it on “its own dedicated computer in the cloud”; Instinct’s terms have drawn criticism for granting a “perpetual and irrevocable” licence over what you share. With Hermes, the memory is two Markdown files on a machine you control, and you can read them. The price is that you are the product team: you host it, you wire in each account, and you decide when it may speak.

An ambient assistant is three parts: something that remembers you, somewhere you already talk, and a reason to speak first.

The pieces are there. The work that’s left is judgement: what it should notice, when it should interrupt, and what it should never do without asking. That part was never going to come in a box.