The Hermes Agent Profile Builder lets you configure a fully isolated AI agent — identity, model, skills, and MCP server integrations — without writing a single terminal command. Nous Research shipped this feature as part of the Hermes Agent local web dashboard, collapsing what used to be several CLI steps into a single guided browser flow.
If you’ve been building with open-source AI agents and found the setup friction exhausting, the Hermes Agent Profile Builder is the most significant quality-of-life upgrade in Hermes to date.
What Is Nous Research’s Hermes Agent?
Definition: Hermes Agent is an open-source, self-improving AI agent developed by Nous Research. It runs across a CLI, a native desktop application, and messaging platforms, and is designed to operate locally — meaning all data stays on your machine by default.
Expansion: Unlike cloud-first agent platforms, Hermes is built around the concept of profiles — fully isolated agent home directories. Each profile owns its own configuration file (config.yaml), environment variables (.env), personality file (SOUL.md), memory, sessions, scheduled tasks (cron jobs), and a state database. This architecture means you can run a coding agent and a research agent side by side on the same machine without them ever sharing memory or credentials.
Hermes has gained significant traction in the open-source agent ecosystem, topping OpenRouter’s global usage rankings against competing frameworks. The addition of the Hermes Agent Profile Builder continues that trajectory by significantly lowering the barrier for new users.
What Is the Hermes Agent Profile Builder?
Definition: The Hermes Agent Profile Builder is a guided web UI, embedded inside the Hermes local dashboard, that walks a user through every configuration decision needed to create a new agent profile — from naming and identity to model selection, skill installation, and MCP server attachment — and writes the results to the profile’s standard config files.
Expansion: Before the Profile Builder existed, creating a distinct Hermes agent meant executing a series of CLI commands: hermes profile create, followed by setup, then model configuration, then skill installation, then manually editing the mcp_servers block in config.yaml. Each of those steps had its own syntax and documentation page. The Hermes Agent Profile Builder bundles all five of those configuration groups into a single, linear browser form.
The dashboard runs at http://127.0.0.1:9119 after you execute hermes dashboard. The loopback-only default means no configuration data is exposed outside your local machine unless you explicitly change the bind address.
How the Hermes Agent Profile Builder Works: A Step-by-Step Walkthrough
The Hermes Agent Profile Builder organizes configuration into five distinct groups. Understanding each one helps you build more purposeful, better-isolated agents.
Step 1 — Identity: Name and Description
The agent’s name is more than a label. When you create a profile named researcher, Hermes automatically generates a shell command alias: researcher chat. The name flows through the entire profile, becoming the command prefix for every interaction. The description field provides human-readable context and can be queried later for documentation purposes.
Deeper personality lives in the profile’s SOUL.md file. The builder creates this file during profile initialization; you can edit it afterward to give the agent a specific communication style, set of operating rules, or domain focus.
Step 2 — Model and Provider Selection
The Hermes Agent Profile Builder supports a wide range of model providers out of the box, including Nous Portal, OpenRouter, NVIDIA, OpenAI, and any custom OpenAI-compatible endpoint. This flexibility means you can point a single Hermes profile at a locally-hosted model via LM Studio or Ollama, or route to a cloud provider for heavier workloads.
Model selection made in the builder lands in config.yaml under the model.default key. You can change the model at any time without rebuilding the entire profile using hermes model.
Step 3 — Skills: Built-In Toggles and Hub Installs
What is a Hermes skill? A skill is a SKILL.md file with three parts: a name, a short description, and a full procedure. The agent reads short descriptions on every request to decide relevance, but only loads a skill’s full content when a task actually requires it. This lazy-loading architecture means you can attach dozens of skills to a profile without bloating every prompt with irrelevant context.
The Hermes Agent Profile Builder exposes two routes for skills:
- Built-in skills are toggles. The builder lists Hermes’s core toolsets; you flip them on or off per profile. Disabled toolsets are recorded under
agent.disabled_toolsetsin the config. - Skills Hub installs let you search an external catalog and install third-party skills by slug identifier, the way you would install a package from npm or PyPI.
Step 4 — MCP Servers: HTTP and stdio
What is an MCP server in the context of Hermes? MCP (Model Context Protocol) servers expose external tools to the agent. Hermes accepts two types: HTTP servers provided via a URL (with optional authorization headers), and stdio servers invoked via a local shell command.
The Hermes Agent Profile Builder connects to a Nous-approved catalog of MCP servers, supporting one-click installs that prompt inline for any required API keys. Common examples include filesystem access servers, GitHub integrations, and documentation fetch servers.
MCP servers are written to the mcp_servers map in config.yaml, keyed by server name — not as a list. This distinction matters when you’re editing configs manually after the fact.
Hermes Agent Profile Builder vs. CLI: Key Differences
The Hermes Agent Profile Builder does not replace the CLI. It mirrors it in a browser form. Both paths write to the same profile directory. The choice between them is about friction, not capability.
| Configuration Step | Profile Builder (Dashboard) | CLI Equivalent |
|---|---|---|
| Create and name a profile | Name field in the builder form | hermes profile create <name> |
| Add a description | Description field | --description "..." or hermes profile describe |
| Set model and provider | Model picker dropdown | <profile> config set model <id> |
| Toggle built-in skills | On/off toggles | <profile> skills list / toggle |
| Install from Skills Hub | Search and install UI | <profile> skills install <slug> |
| Attach MCP servers | Add form or catalog install | Edit mcp_servers or <profile> mcp install |
| Provide API keys | Inline key prompts | <profile> setup |
The CLI remains the right tool for scripting, CI pipelines, and programmatic agent provisioning. The Hermes Agent Profile Builder is the right tool when you want to stand up a new agent interactively in under two minutes.
Real-World Use Cases for the Hermes Agent Profile Builder
The profile-per-agent model that the builder enforces by design unlocks several practical workflows:
- Isolated coding assistant. Create a profile with a code-focused model, a filesystem MCP server scoped to a single project directory, and Git and test-runner skills. This agent never sees your personal notes or email drafts because profiles never share state.
- Research agent with web skills. Pair a high-context model with web-extract skills. Every research session writes to that profile’s memory database, building a persistent, queryable knowledge base that stays separate from your other work.
- Operations bot with scheduling. Attach a messaging channel gateway and configure cron tasks for recurring reports. Each profile holds its own bot token; a built-in token lock prevents two profiles from accidentally sharing credentials.
- Client-specific agents. Agencies and consultants can spin up one profile per client engagement. The Hermes Agent Profile Builder makes this fast enough to do at the start of an engagement rather than as a late-stage optimization.
- Experimental model comparisons. Clone an existing profile and swap only the model field. Run the same task on two profiles to compare outputs without contaminating either agent’s memory.
What the Hermes Agent Profile Builder Actually Writes to Disk
Understanding what files the builder produces helps with debugging and version control. The builder doesn’t create any proprietary format — it writes to the same files the CLI reads.
config.yaml receives the model provider string, model ID, mcp_servers map, and any disabled toolsets. A research profile’s config might look like this:
yaml
model:
default: anthropic/claude-sonnet-4
mcp_servers:
filesystem:
command: npx
args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]A remote HTTP MCP server uses url and headers keys instead of command:
yaml
mcp_servers:
docs:
url: "https://mcp.example.com/mcp"
headers:
Authorization: "Bearer ${DOCS_API_KEY}".env receives API keys collected during inline prompts. Keys are stored per-profile, so rotating a credential for one agent doesn’t affect others.
SOUL.md is initialized with a default personality template during profile creation. Edit it afterward to refine the agent’s communication style, domain focus, or operating constraints.
How to Install and Access the Hermes Agent Dashboard
The Profile Builder requires the web optional dependency, which ships the HTTP dashboard stack. The base hermes-agent install does not include it.
bash
pip install 'hermes-agent[web]'Once installed, launch the dashboard with:
bash
hermes dashboardThe dashboard opens at http://127.0.0.1:9119. The Profile Builder lives inside it alongside other management views for memory, sessions, skills, and cron jobs. The loopback bind is the default for security; exposing the dashboard to a network interface requires explicit configuration and an auth provider.
Strengths and Limitations of the Hermes Agent Profile Builder
Every tool makes tradeoffs. Understanding both sides helps you decide where the builder fits in your workflow.
Strengths:
- Consolidates five separate CLI operations into one linear form, dramatically reducing new-agent setup time.
- All outputs are standard
config.yamland.envfiles — fully portable and version-controllable. - Catalog-driven MCP and skill installs handle API key prompting inline, removing a common setup error.
- Dashboard binds to loopback by default, keeping agent configuration off the network.
- The skill lazy-loading design means adding skills in the builder doesn’t bloat runtime prompts.
Limitations:
- Profiles do not sandbox filesystem access at the OS level on the local backend; the isolation is logical, not enforced by containers or permissions.
- Exposing the dashboard beyond localhost requires a separately configured auth provider — the builder does not ship one.
- Skill and MCP server changes applied through the builder take effect on the next session or gateway restart, not immediately.
- Some controls in the builder duplicate settings accessible on other dashboard pages, which can create minor confusion about the canonical location.
Why the Hermes Agent Profile Builder Matters for Open-Source AI Agents
The broader significance of the Hermes Agent Profile Builder isn’t the feature itself — it’s what it signals about the maturation of open-source agentic infrastructure.
For most of the early AI agent era, serious local agent frameworks were effectively CLI-only tools. That restricted their reach to developers comfortable with terminal-based configuration. Dashboard-first tooling like the Profile Builder changes the adoption surface. A researcher, a data analyst, or a product manager can now configure a Hermes agent without learning the profile command syntax.
More importantly, the builder preserves the architecture that makes Hermes powerful: profile isolation, lazy skill loading, explicit MCP server attachment, and local-first data storage. It doesn’t trade capability for accessibility. It makes the same capable system available to a wider audience.
The convergence of local-first design, MCP protocol support, and visual configuration puts Hermes Agent in a distinct position relative to cloud-native agent platforms. While hosted platforms abstract infrastructure away entirely, the Hermes Agent Profile Builder gives users full visibility into what their agent is configured to do — and where their data goes.
Frequently Asked Questions
What is the Hermes Agent Profile Builder? The Hermes Agent Profile Builder is a browser-based configuration wizard inside the Hermes Agent local dashboard. It lets you define an agent’s name, model, skills, and MCP server connections in a single guided form, then writes those settings to standard config files.
Is the Hermes Agent Profile Builder free and open source? Yes. Hermes Agent is an open-source project from Nous Research. The Profile Builder is included in the hermes-agent[web] package at no cost.
How is a Hermes profile different from a regular AI chat session? A profile is a fully isolated agent home directory with its own config, memory database, API keys, scheduled tasks, and skills. It persists between sessions and never shares state with other profiles on the same machine.
Can I use the Hermes Agent Profile Builder without a GUI? The builder is a web UI, so it requires a browser. All the same configuration can be done via CLI commands if you prefer a headless environment. Both paths write to the same profile files.
Does using the builder prevent me from editing config files manually afterward? No. The builder writes standard YAML and env files. You can edit them directly at any time. The builder is a creation tool, not a lock-in mechanism.
What MCP servers can I attach through the Profile Builder? Any stdio MCP server (via local shell command) or HTTP MCP server (via URL with optional auth headers). The builder also connects to a Nous-approved catalog for one-click installs of popular integrations.
What happens if I add a skill in the Profile Builder while an agent session is active? Skill changes take effect on the next session start or gateway restart. Active sessions do not pick up new skills mid-conversation.