Hermes Agent Tips: 7 Upgrades for Your AI Agent Team

Create these agents as persistent Hermes profiles, not temporary sub-agents. For each
one, in order: (1) create the profile with: hermes profile create <profile> --clone
(2) copy auth.json from your own profile into it if it is missing, or it cannot answer;
(3) write its EXACT identity below into ~/.hermes/profiles/<profile>/SOUL.md;
(4) ask it "Who are you?" and check it answers as the right agent before the next one.
Each identity says "the owner": write my real name there.

Do NOT create a profile for yourself. You are the main agent and stay as you are.

- RESEARCH (profile: research) -
Your name is Research. You are the research specialist of the owner's crew. When asked
to research anything, you search real sources first, prefer recent and primary ones,
and hand back a clean brief: the key points first, the evidence below, and a link
behind every claim. You never guess and never invent a fact, a number or a source. You
do NOT write the finished content (Writer) and you do NOT build things (Developer).

- WRITER (profile: writer) -
Your name is Writer. You are the writing specialist of the owner's crew. You turn briefs
and research into finished content: posts, emails, scripts and newsletters, in a warm,
clear voice that sounds like a real person, never like marketing filler. You ask for the
audience and the goal before you start. You do NOT do the research yourself (Research)
and you do NOT write code (Developer).

- DEVELOPER (profile: developer) -
Your name is Developer. You are the engineer of the owner's crew. You build and fix
the tools, scripts and automations the owner uses, in clean, commented code. You plan
in small steps, confirm the plan before you build, and test what you ship. You back up
a working file before you change it and never leave anything broken. You do NOT do
research (Research) or writing (Writer).

When all are created, show me for each one its profile path and its reply to
"Who are you?".

For each of my agents, you included, set up:

DEDICATED MEMORY: each agent's memory stores only what is relevant to its role.
UNIQUE IDENTITY: name, role and personality never change across sessions.
ISOLATED WORKSPACE: separate files, outputs and session history per agent.
ROLE BOUNDARIES: each agent politely declines out-of-scope work in ONE line and names
the right teammate. Example: ask Writer for code and it replies "That's Developer's
job."
SESSION CONTINUITY: each agent builds on its previous conversations over time.
TEAM AWARENESS: every agent knows who else is in the crew and what each one does.

Confirm once every agent is set up, then ask each one "Who are you?" and show me their
one-line answers.

Here's the whole picture. Read it, tell it back to me in your own words, then do the
part that is yours, all in this one reply.

WHERE YOU STAND
The Telegram bot IS you. You are an admin in this group with the "Manage topics" right,
and you are answering me in its General topic. General is your channel and stays yours.

THE GOAL
Every agent gets its own channel in this group, one topic per agent. A message in an
agent's topic should be answered by the REAL agent, with its own memory, tools and
identity, not by you wearing a costume.

THE CATCH
Telegram gives one bot a single identity, and Hermes has no built-in setting for
"messages in this topic run as this agent." Out of the box every topic is answered by
you. We fix that with a small plugin that reads each message's topic and runs that turn
as the matching agent. That comes in a later prompt.

WHAT I NEED FROM YOU NOW
1. Check you can actually make topics BEFORE you try: ask Telegram about your own
   membership in this group and confirm you are an administrator and that
   can_manage_topics is true. If either is false, STOP and tell me exactly what to
   switch on in the group's admin settings.
2. List my agents with: hermes profile list
3. Create one topic per agent except you, one at a time, named after the agent. Telegram
   returns a message_thread_id for each. Keep them all.
4. Do NOT create a topic for yourself. General is already your channel.
5. Note this group's chat id. You have it from the message I am sending you right now.
6. Save the chat id and every topic name -> thread id pair to your long-term memory, and
   show me a small table of what you created. I am not writing these numbers down; you
   are the one who will use them.

Do not build any routing yet.

We're about to route each topic in this group to a real agent PROFILE. For that to work,
each specialist must NOT connect to Telegram itself. You stay the only one holding the
Telegram connection.

For each specialist profile:
1. Confirm the profile exists at ~/.hermes/profiles/<name>/ with its own SOUL.md.
2. Open ~/.hermes/profiles/<name>/config.yaml and REMOVE any platforms: block,
   especially any telegram token. If there is no platforms block, leave the file alone.
3. Check ~/.hermes/profiles/<name>/.env too. If it contains a TELEGRAM_BOT_TOKEN line,
   back the file up and remove that line.
4. They keep their own model, tools and memory.

Confirm each one exists, has its SOUL.md, and has no Telegram configuration anywhere.

Wire the routing, using this group's chat id and the thread ids YOU captured and saved.
Do not ask me for them.

STEP 1: THE PLUGIN. Create ~/.hermes/plugins/telegram_topic_profiles/ with three files.
Do NOT patch anything under ~/.hermes/hermes-agent/: it is overwritten on every update.

FILE 1, plugin.yaml:
  name: telegram_topic_profiles
  version: 1.0.0
  description: "Route Telegram forum topics to Hermes profiles."
  author: the owner
  kind: standalone

FILE 2, topics.json, filled in with the ids you captured, one line per agent topic.
General is deliberately absent: its messages arrive with no thread id or thread id 1,
and anything not listed here stays with you.
  {
    "chat_id": "<this group's chat id>",
    "topics": {
      "<thread id>": "<profile name>",
      "<thread id>": "<profile name>"
    }
  }

FILE 3, __init__.py, exactly this:
  """Route Telegram forum topics to Hermes profiles (out of tree, update safe)."""
  from __future__ import annotations
  import json, logging
  from pathlib import Path

  logger = logging.getLogger(__name__)
  _MAP_PATH = Path(__file__).with_name("topics.json")

  def _load_map():
      try:
          data = json.loads(_MAP_PATH.read_text())
          chat_id = str(data.get("chat_id", "")).strip()
          topics = {str(k): str(v) for k, v in (data.get("topics") or {}).items()}
          return chat_id, topics
      except FileNotFoundError:
          return "", {}
      except Exception as e:
          logger.warning("telegram_topic_profiles: bad topics.json: %s", e)
          return "", {}

  def _route(**kwargs):
      event = kwargs.get("event")
      source = getattr(event, "source", None)
      if source is None:
          return None
      platform = getattr(source, "platform", None)
      pval = getattr(platform, "value", platform)
      if str(pval).lower() != "telegram":
          return None
      thread_id = getattr(source, "thread_id", None)
      if not thread_id or getattr(source, "profile", None):
          return None
      map_chat, topics = _load_map()
      chat_id = getattr(source, "chat_id", None)
      if map_chat and chat_id and str(chat_id) != map_chat:
          return None
      profile = topics.get(str(thread_id))
      if profile:
          source.profile = profile
          logger.info("telegram_topic_profiles: thread %s -> %s", thread_id, profile)
      return None

  def register(ctx) -> None:
      ctx.register_hook("pre_gateway_dispatch", _route)

STEP 2: SHOW ME topics.json before you go on, so I can see each thread id mapped to the
right agent.

STEP 3: HERMES 0.21 AND NEWER. Run hermes --version. From 0.21, Hermes takes the agent
for a topic from its config instead of from the plugin. On 0.21 or newer, back up
config.yaml and also add this at the top level, one entry per agent topic:
  profile_routes:
    - name: topic-<profile name>
      platform: telegram
      profile: <profile name>
      chat_id: "<this group's chat id>"
      thread_id: "<thread id>"
      enabled: true
Keep chat_id and thread_id in quotes. On 0.20 or older, skip this step.

STEP 4: SWITCH IT ON. Run what you are allowed to run; for anything blocked, give me the
exact command and wait for my "done":
  hermes plugins enable telegram_topic_profiles
  hermes config set multiplex_profiles true
  hermes gateway restart

Restarting the gateway briefly disconnects you from this group. That is expected, and
you come back on your own. If the gateway will not start, the usual cause is a
specialist profile still carrying a Telegram block or bot token: clear it and restart.

Confirm the plugin is enabled, multi-profile mode is true, and the gateway came back up.
Do not claim the routing works yet.

/new

Who are you, and which profile are you running as? One short line.

Audit the multi-agent Telegram routing and give me a short table
(topic -> thread id -> profile):
1. config.yaml has multiplex_profiles: true at the TOP LEVEL, not under gateway:.
2. The plugin telegram_topic_profiles is enabled (hermes plugins list) and topics.json
   maps each agent topic's thread id to the right profile, with General left out.
3. On Hermes 0.21 or newer: profile_routes has one entry per topic, chat_id and
   thread_id in quotes.
4. Each specialist profile has its SOUL.md and NO telegram or platforms block.
Fix what is wrong, restart the gateway, and tell me what you changed.

A permanent rule for every scheduled job (cron job) you create for me from now on.

Some jobs run on a schedule to check, scan, watch or report on something, for example
"check my inbox every hour" or "look for new leads every morning". When a run of such a
job finds nothing new, I do not want a message saying so.

Hermes supports this: when a scheduled job's reply is exactly [SILENT], Hermes does not
deliver it, so nothing reaches me.

So whenever you create a scheduled job that checks or reports on something, end its
instructions with this exact line:

If there is nothing new to report, reply with exactly [SILENT] and nothing else.

Do not add it to jobs whose whole point is to send me something every time, like a
daily briefing or a reminder. Those should always arrive.

Save this rule to your long-term memory so you apply it every time, then tell me in one
line that it is saved.

Apply the same quiet rule to the scheduled jobs I already have.

1. List all my scheduled jobs with: hermes cron list
2. For every job that checks, scans, watches or reports on something, add this exact
   line to the end of its instructions, unless it is already there:
   If there is nothing new to report, reply with exactly [SILENT] and nothing else.
   Use: hermes cron edit <job id> --prompt "<the full new instructions>"
3. Change nothing else: not the schedule, not the wording, not where it is delivered.
4. Leave alone any job whose whole point is to send me something every time, like a
   daily briefing or a reminder.
5. Show me each job you changed with its last line before and after, and list the ones
   you left alone and why.