One Agent, Many Faces: Why I Stopped Creating Separate Profiles

I’ve been running Hermes Agent for a few weeks now — it’s an autonomous AI agent that lives in my terminal and on my Discord server. One thing that kept nagging me was the question: do I need separate profiles for different tasks?

The natural instinct

Hermes has a profile system. You can create isolated agent instances — each with its own config, memory, skills, sessions. The natural instinct, when you start using an agent for different things, is to think: “I want a coder agent with a coding-focused model and persona, a research agent that’s thorough and academic, a casual chat agent that’s quick and conversational.”

Each of these roles seems to want different things. My general-purpose agent is fine running on GLM-5 Turbo with a friendly default personality. But when I’m coding, I’d prefer Claude Sonnet with a focused, minimal persona that doesn’t waste tokens on pleasantries. A research agent might want a different model yet, with a personality that’s meticulous and cites sources.

So you’d make separate profiles for each. Right?

That’s exactly where I started. And then I hit a wall.

The memory problem

Here’s where profiles broke down for me. Over these few weeks, my agent has built up a rich web of contextual knowledge about how I work. It knows that I use Notion for long-term knowledge and meeting notes. It knows Obsidian runs my LLM wiki. It knows Todoist is my task system. It knows my workspace layout, my git conventions, which API keys live where, and a dozen other nuances that I’ve trained into it — sometimes explicitly, sometimes just by correcting it when it guessed wrong.

This isn’t generic “AI assistant” knowledge. It’s my operational context, built up over weeks of use. And it lives in the agent’s memory.

Hermes profiles are fully isolated. Each profile gets its own memory store. So if I create a “coder” profile and a “general” profile, the coder agent starts from zero — it doesn’t know any of the above. I’d have to recreate that context in every profile, or point them all at some external shared memory source. Both options felt wrong. Recreating is tedious and fragile. External shared memory is architecturally possible but feels like a hack — you’re working around the isolation that profiles gave you in the first place.

This was the moment I stepped back and questioned whether profiles were even the right tool for what I was trying to do.

What I actually wanted

The problem I was trying to solve wasn’t “I need separate agents with separate everything.” It was much simpler: I wanted the same agent to behave differently depending on what I was doing. Same memory. Same skills. Same context. Just a different surface behavior.

Hermes supports exactly this, and it doesn’t require profiles. You can switch personality mid-conversation with /personality, and swap models with /model. The agent keeps all its context — it remembers what you were working on, what skills it has, what’s in its memory. Only the surface behavior changes.

This is fundamentally different from what a profile gives you. A profile is a wall. Personality switching is a mask. And for my use case, I didn’t need walls. I needed masks.

The routing question

The other thing that sent me down the profiles path was Discord routing. I wanted different channels on my server to get different treatment — maybe a focused coding personality in #dev and something more relaxed in #general.

Hermes doesn’t support per-channel routing within a single gateway instance. Each Discord bot token maps to one profile. To get different profiles in different channels, you’d need multiple gateway instances, multiple bot tokens, multiple bot invites — a lot of operational overhead for what amounts to a personality change.

But even setting that aside, would I want fully isolated agents per channel? If my coding agent helped me debug something in #dev, I’d want the #general agent to know about it too. Shared memory is a feature, not a limitation.

When profiles actually make sense

After going back and forth, I’ve settled on a clear rule: profiles are for physical separation, not role separation.

Use a profile when:

You have genuinely different workspaces — work projects vs personal projects that shouldn’t share files, API keys, or Notion databases
You need different API providers — work uses one LLM provider, personal uses another, different billing accounts
You’re running Hermes for different organizations that shouldn’t share any state at all

Don’t use a profile when:

You want a different tone or personality for the same agent — use /personality
You want a different model for a specific task — use /model
You want a “coder” vs “researcher” distinction — the agent can do both; prompt it differently
You’re trying to solve what is essentially a configuration problem

The real insight

The confusion comes from conflating two different things:

Separation of concerns — “I don’t want my work stuff and personal stuff mixed” → This is what profiles are for.
Variation of behavior — “I want the agent to behave differently in different contexts” → This is what personality and model switching are for.

These are orthogonal axes. You can have one profile with multiple personalities. You can have multiple profiles with the same personality. The mistake I made was reaching for profiles to solve a personality problem — and then realizing the memory cost was too high to pay.

It’s like realizing you don’t need a second apartment just because you want to wear different clothes. You just need a closet.