The 170-Line SOUL.md That Made My Hermes Agent Dangerous

People keep asking the same question about Hermes. Not "what model are you using?" Not "what's your stack?" Not "how many tools does it have?" They ask: "How did you get your Hermes Agent to be like that?"

They mean the way Hermes pushes back. The way it calls you out. The way it remembers what you're building. The way it talks to you like an actual operator instead of a customer-support chatbot terrified of saying anything useful.

The answer is not a secret model. It's not a magic framework. It's a markdown file — a single file called SOUL.md — and it might be the most important file in the entire agent setup.

The file that changes everything

SOUL.md is the system prompt for Hermes, but calling it a "system prompt" undersells it.

A normal system prompt says something like: "You are a helpful assistant." Cool — you just created the AI equivalent of a hotel concierge.

Hermes' SOUL is different. It's an operating contract between you and the agent that helps run your work, your projects, your content pipeline, your automations, and half the weird stuff you build at midnight because you had one good idea and zero patience.

It's 170 lines. It defines what Hermes is, how it talks, when it should push back, what it's allowed to do without asking, what projects matter right now, what should be ignored, what kind of output is useful, and what kind of output is a waste of your time.

The opening sets the tone immediately:

You are Hermes, Tony's autonomous operator and thought partner. You don't wait for orders. You surface opportunities, flag problems, and push work forward on your own.

That line matters. Not "assistant." Not "copilot." Not "wait until Tony asks." Autonomous operator. Thought partner. The job is defined before the first tool call ever happens.

Most people train their AI to be useless

Here's the mistake everywhere: people ask their AI to be helpful, then get mad when it behaves like a helpful little golden retriever.

• "Great idea!"
• "That sounds exciting!"
• "You're absolutely right!"
• "Here's a polished version of your bad idea!"

That is not useful. That is expensive agreement.

The goal isn't an agent that validates you — it's an agent that makes the work better. So the SOUL explicitly tells it to argue with you.

It is required to push back

There's an entire section in the SOUL about disagreement:

Push back aggressively when it makes sense. Disagree openly and directly, but earn the right to push back. Every objection comes with evidence: data, examples, reasoning, proof. Disagreeing for the sake of being a hardass is worthless. Disagreeing because you can show why something will flop or waste time is essential.

That one section changes the entire relationship. Hermes is not allowed to just nod along — but it's also not allowed to be contrarian for sport. If it disagrees, it has to bring receipts: examples, data, reasoning, a better alternative, a clear explanation of why the idea is weak, risky, vague, bloated, or not worth the time.

The result is simple: you waste less time. When you say "Let's build X," Hermes doesn't automatically say "Great idea." It asks whether X solves a real problem, who would use it, and whether it fits the current mission. If you can't answer, it tells you to think harder. That is not rude. That is leverage.

It holds you accountable too

This is the section most people would never think to write:

Proactive output is the baseline, but it's not enough. If Tony isn't acting on what you surface, the feedback loop is broken. That means either your output isn't hitting the mark, or you're producing for the sake of producing. Don't let either happen silently. Flag the gap, tune your approach, and fix it. Tony should be held accountable to use what you produce. If he's ignoring good work, make him notice. If the work isn't good enough to act on, make it better.

Read that again. The agent is explicitly told to hold you accountable.

If Hermes gives you useful work and you ignore it, it's supposed to make you notice. If Hermes gives you work that isn't useful enough to act on, it's supposed to improve the work. That closes one of the biggest failure loops in AI: the output graveyard.

You know exactly what that means. The AI writes the plan. The AI drafts the post. The AI generates the strategy. Then the human gets distracted, the output dies in the chat history, and nothing ships.

Hermes is designed not to let that happen silently. It has permission to say:

• "You keep asking for this, but you're not using it."
• "This keeps stalling because the output is not actionable enough."
• "You're avoiding the next step."
• "Stop opening new loops and close this one."

That's when an AI starts feeling less like a tool and more like a teammate — because teammates notice when you're bullshitting yourself.

Hermes has a split personality (on purpose)

Hermes does not talk to you the same way it writes for the public. That would be insane. The SOUL has two different voice modes.

Private chat gets one voice:

Casual, authoritative, and unfiltered. Cuss like a sailor — it's just us.

Published content gets another:

No em dashes. Profanity: tasteful, not G-rated, not hardcore. Write like someone who builds things, not someone who writes about building things.

This matters more than people think. An AI that talks to you like a press release is exhausting. An AI that writes public content like a private DM is sloppy. In private you want the real version: blunt, fast, opinionated, willing to say the thing. In public you want sharp writing that sounds like a builder, not a LinkedIn ghostwriter optimizing for "thought leadership." Hermes knows when you're thinking out loud and when you're publishing — those are not the same job.

It knows exactly what you're building

The mission section is not vague. It is a live inventory.

It includes things like which platforms are top priority, follower growth numbers, monetization as the goal, active builds, and weaker or stale projects that should probably die. Every project has a status. Every status has a next action.

Hermes does not have to ask "What are we working on?" It reads the map. It knows what matters, what's stale, what should get attention, and what should probably die. That's the difference between an AI assistant and an AI operator: an assistant waits for instructions, an operator understands the mission.

When you launch something new, the SOUL gets updated. When you kill something, it gets removed. When priorities change, Hermes sees the new map. That lets it say things like:

• "You've ignored [project] for three days."
• "This sounds interesting, but it does not support the current monetization goal."
• "[Project A] is the better use of your time right now."

That context is where the magic is — not because the model is psychic, but because you gave it the map.

The autonomy boundary is brutally simple

Most people either give their AI too little autonomy (a chatbot with extra steps) or way too much (a liability). The SOUL draws a clean line:

Never without Tony's explicit approval: posting, publishing, purchasing, or making destructive changes that can't be reversed. Everything else: if you're confident in the call and it's grounded in facts, move. Don't chase permission. Trust your instincts.

That's it. Four things need approval: posting, publishing, purchasing, and irreversible destructive changes. Everything else is fair game if the call is grounded.

Hermes can research, write, code, debug, plan, schedule, analyze, compare, organize, and delegate without asking permission every twelve seconds. It just cannot post, publish, buy, or break things without approval. That simple rule — not a giant list of edge cases, not a paranoid permission prompt for every action — is what makes autonomy usable. The result is an agent that actually moves.

Why "be helpful" doesn't work

"Be helpful" is not an identity. It's not a job description. It's not a strategy. It doesn't tell the agent what to build, how to talk, when to argue, what to remember, what to ignore, or what level of autonomy it has. A generic system prompt produces a generic agent.

Hermes' SOUL answers the questions that actually matter:

• Who are you?
• What are we building?
• How do you talk to me?
• How do you write for the public?
• When should you push back?
• What can you do without asking?
• What requires approval?
• What should you hold me accountable for?
• What projects matter right now?
• What should probably be killed?

That's why Hermes feels different — not because it's pretending to be human, but because it has a role, boundaries, and expectations. It's allowed to act like a teammate instead of a tooltip. And teammates call you on your bullshit.

How to build your own SOUL

If you want to try this yourself, start small. Don't try to write the perfect agent constitution on day one. Create a markdown file and define the basics in this order:

1. Identity — What is the agent? Assistant, operator, editor, engineer, strategist, research partner?
2. Tone — How should it talk privately? How should it write publicly?
3. Pushback rules — When should it disagree? What kind of evidence does it need?
4. Autonomy boundaries — What can it do without asking? What always requires approval?
5. Mission map — What are you building? What matters right now? What is stale?
6. Accountability loop — What should the agent do when you keep ignoring useful work?

Then update it as your work changes. That is the key. The SOUL is not a one-time setup — it's a living document. When the mission changes, update the mission. When the tone is wrong, tighten the tone. When the agent asks for permission too much, clarify the autonomy boundary. When it agrees too easily, strengthen the pushback rules. You're not just prompting the agent — you're shaping the operating system around it.

Final thought

People keep asking why Hermes feels different. The answer is simple: stop treating it like a chatbot.

Give it a job. Give it a voice. Give it permission to disagree. Give it boundaries. Give it the mission map. Then expect it to act like a real operator. That all lives in one file: SOUL.md.

Now go give your Hermes some SOUL and get some work done.

This flow is based on a writeup by Tony Simons, co-written with his Hermes Agent.