Hermes Agent Profiles: turning one assistant into six manageable work identities

The common mistake is to treat a profile as a nickname. It isn't. In Hermes Agent, a profile is closer to a separate desk: its own config, environment variables, skills, memory, sessions, cron jobs, logs, and gateway state. From Feishu or Telegram, it may still look like a chat bot. Under the hood, the selected profile decides which model, credentials, tools, memories, and routines are loaded.

That matters once the agent starts doing real work. A publishing assistant should not quietly inherit operations credentials. A code-review agent should not carry personal-assistant memory. An on-call bot should not be polluted by writing habits. Profiles are not about making the model smarter. They are about making the agent's operating boundary visible.

What a Hermes profile actually isolates

According to the Hermes Agent documentation, the default profile lives at ~/.hermes. Named profiles live under ~/.hermes/profiles/<name>. Each profile has its own local state, including:

• config.yaml: model, provider, tools, terminal, memory, delegation, and related settings.
• .env: API keys, Feishu app credentials, Telegram bot tokens, and other secrets.
• skills/: the skill library visible to that profile.
• memories/: profile-specific memory and user notes.
• sessions/: conversation history.
• cron/: scheduled jobs.
• gateway.pid and gateway_state.json: runtime state for that profile's messaging gateway.

There is one important limit: a profile is not an operating-system sandbox. It separates Hermes state. It does not automatically restrict filesystem access. If the terminal backend runs as your macOS or Linux user, the agent still has whatever filesystem permissions that user has. For hard isolation, use a separate working directory, container, remote machine, locked-down credentials, or a narrower toolset.

Why multiple profiles are useful

One default profile is fine for casual chat. It becomes messy when the agent becomes part of your daily operations. Writing preferences, code repositories, Feishu groups, publishing tokens, GitHub permissions, and scheduled jobs all start to share one room. When something goes wrong, you don't know whether the issue is model config, memory contamination, a disabled tool, or the wrong bot answering.

Multiple profiles fix that in a boring but valuable way:

• Role separation: writer writes, reviewer checks, ops monitors.
• Credential separation: different Feishu apps, API keys, and GitHub tokens live in different .env files.
• Memory separation: a personal assistant remembers personal context; an engineering assistant remembers project conventions.
• Gateway separation: each profile can run its own messaging bot.
• Schedule separation: reports, monitors, publishing jobs, and maintenance tasks do not all sit in one cron folder.

Creating six profiles

A practical six-profile setup might look like this:

hermes profile create orchestrator --description "Breaks work down, delegates, checks results"
hermes profile create researcher --description "Researches docs, source material, and facts"
hermes profile create writer --description "Drafts bilingual articles and publishing copy"
hermes profile create reviewer --description "Reviews code, claims, and final output"
hermes profile create ops --description "Handles gateway, cron, logs, and service status"
hermes profile create feishu-bot --description "Feishu entry point for chats and groups"

If you want a new profile to inherit the default model configuration, base skills, and selected memory files, use cloning:

hermes profile create writer --clone --clone-from default
hermes profile create ops --clone --clone-from default

--clone is usually the sensible option for day-to-day setup. --clone-all copies more runtime state and is better treated as a migration or backup tool, not a habit for creating every new role.

Using a profile from the command line

The explicit form is the safest:

hermes -p writer chat
hermes -p researcher chat -q "Research the Hermes profile docs"
hermes -p ops doctor
hermes -p feishu-bot gateway start

If aliases were created, the profile name can also behave like a wrapper command:

writer chat
researcher chat
ops gateway status

You can set a sticky default profile:

hermes profile use writer
hermes chat
hermes profile use default

For anything with side effects — publishing, restarting gateways, sending messages, running scheduled jobs — I would still use the explicit -p profile_name form. It makes the active identity obvious.

Using profiles from Feishu

Feishu does not switch Hermes profiles inside a message. The cleaner model is: run a separate gateway under the profile you want.

hermes -p feishu-bot gateway setup
hermes -p feishu-bot gateway start

That profile's Feishu credentials live in:

~/.hermes/profiles/feishu-bot/.env

Common variables include FEISHU_APP_ID, FEISHU_APP_SECRET, FEISHU_CONNECTION_MODE, FEISHU_ALLOWED_USERS, and FEISHU_HOME_CHANNEL.

If you want six Feishu-facing profiles running at the same time, the most reliable setup is six Feishu/Lark bot apps, one per profile. Each app has its own credentials. Each profile runs its own gateway. In WebSocket mode, each bot connects outbound, so there is no local webhook port fight. In webhook mode, the default port/path will collide unless you assign different ports or put a reverse proxy in front.

One small operational detail matters: Feishu open_id values are app-scoped. The same human can have different open IDs under different Feishu apps. If you use FEISHU_ALLOWED_USERS, verify the IDs for each app instead of copying one allowlist everywhere.

What these six profiles can do

• orchestrator: receives a large request, breaks it into tasks, asks other profiles or subagents for work, and checks the final result.
• researcher: reads public docs, local source files, and web material; keeps write permissions narrow.
• writer: turns verified notes into articles, bilingual drafts, product copy, or Feishu-ready summaries.
• reviewer: checks claims, diffs, tests, formatting, and delivery quality before publication.
• ops: manages gateway status, cron jobs, health checks, and logs. This profile deserves tighter access control.
• feishu-bot: acts as the visible Feishu interface for a team or personal workflow.

The wider pattern: agents are becoming workstations, not chat boxes

Hermes profiles isolate a whole runtime environment. Other agent tools are moving in the same direction at different layers. OpenCode's documentation describes primary agents and subagents: Build has broad tool access, Plan is intentionally more restricted, Explore is read-only for codebase search, and Scout focuses on external docs and dependency research. OpenAI's Codex repository describes Codex as a lightweight coding agent that runs in the terminal. Claude Code users commonly pair separate agents or separate worktrees with different responsibilities during parallel development.

The pattern is simple: the useful unit is no longer “one chatbot.” It is a set of bounded workstations. One can research. One can write. One can review. One can operate services. One can sit in Feishu and talk to people. The boundary is the product.

What X added to the picture

After checking X, the profile story looks less like a quiet configuration feature and more like part of how people are already talking about Hermes in practice.

• Profiles are being used as coordination units. In one reply, Teknium noted that the /hermes-agent skill knows how to run and coordinate multiple Hermes Agent profile CLI sessions to act as an orchestrator. That moves profiles from “separate config folders” to “separate workstations that can be scheduled.”
• Kanban turns profiles into a task network. Teknium described Hermes Agent Kanban as a way to orchestrate tasks across multiple agent profiles and dependencies. A later post described dropping one prompt into triage and letting the orchestrator decompose it into subtasks, assign workers, and track dependencies. The point is not just a board. The point is that profiles can carry worker identities.
• Skills are becoming the portable layer across agents. Nous Research posted that the xurl skill lets Hermes Agent read and write to X on a user's behalf: posting, searching, and pulling bookmarks. Another Nous post said Hermes Agent can access hundreds of browser skills through Browserbase's skills hub. In profile terms, a skill is not just a plugin for one chat window. It is a capability package you can attach to researcher, writer, ops, or Feishu-facing profiles.
• The community is already using “Agent OS” language. Some public posts describe Hermes, Claude, Codex, and OpenClaw in one dashboard and shared-memory frame. That should not be treated as official architecture. But it captures what users actually care about: not one model, but coordination among agents, tools, memory, and workflows.

So the practical meaning of profiles is sharper than “multiple AI personalities.” Profiles help keep Hermes, Codex, Claude Code, OpenClaw, browser skills, X skills, and Crawpress publishing from all living on the same messy desk. Reusable skills can become a shared toolbox. Credentials, memory, cron jobs, and gateways stay profile-scoped. That boundary is what makes coordination survivable.

A practical checklist

• Run hermes profile list before assuming which profiles exist.
• Run hermes profile show writer to check path, model, gateway status, skills, and whether an .env exists.
• Run hermes -p name doctor for each important profile.
• For Feishu profiles, run hermes -p name gateway status.
• After changing tools or config, restart the relevant CLI session or gateway.
• Before publishing, sending, or running cron jobs, confirm the profile explicitly.

Sources

• Hermes Agent Profiles: https://hermes-agent.nousresearch.com/docs/user-guide/profiles
• Hermes Profile Commands: https://hermes-agent.nousresearch.com/docs/reference/profile-commands
• Hermes Feishu/Lark Messaging: https://hermes-agent.nousresearch.com/docs/user-guide/messaging/feishu
• OpenCode Agents: https://opencode.ai/docs/agents/
• OpenAI Codex repository: https://github.com/openai/codex
• Teknium's X reply on coordinating multiple profile CLI sessions: https://x.com/Teknium/status/2043118009485840538
• Teknium's X post on Hermes Agent Kanban across multiple profiles: https://x.com/Teknium/status/2051001156005151226
• Teknium's X post on the Kanban automation upgrade: https://x.com/Teknium/status/2056275882780856741
• Nous Research's X post on the xurl skill: https://x.com/NousResearch/status/2056872329561710766
• Nous Research's X post on Browserbase's skills hub: https://x.com/NousResearch/status/2057147726735774203
• Community X discussion framing Hermes, Claude, Codex, and OpenClaw together: https://x.com/cyrilXBT/status/2059506886953804165

If Hermes is just a question-answering tool, profiles are optional. Once it can publish, restart services, remember project rules, answer inside Feishu, and run scheduled work, profiles stop being a convenience. They become basic hygiene.