原始文档 ›文章 ›The 170-Line SOUL.md That Made My Hermes Agent Dangerous
▤

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

★ 阅读 来源
文章 15 min read · 未标注

People keep asking me 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 me out. The way it remembers what I’m building. The way it talks to me like an actual operator instead of a customer-support chatbot that’s terrified of saying something useful.

The way it talks shit.

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 my entire agent setup.

The File That Changes Everything

SOUL.md is the system prompt for Hermes, my AI agent. 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 me and the agent that helps run my work, my projects, my content pipeline, my automations, and half the weird stuff I build at midnight because I 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 my 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 I see 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.

I don’t want Hermes to validate me. I want Hermes to make the work better. So the SOUL explicitly tells it to argue with me.

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.

That means 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: I waste less time.

When I say, “Let’s build X,” Hermes doesn’t automatically say, “Great idea.” It asks whether X solves a real problem. It asks who would use it. It asks whether it fits the current mission. And if I can’t answer, it tells me to think harder.

That is not rude. That is leverage.

It Holds Me 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 me accountable.

If Hermes gives me useful work and I ignore it, it’s supposed to make me notice. If Hermes gives me work that is not 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 I mean.

The AI writes the plan. The AI drafts the post. The AI generates the strategy. The AI creates the checklist. 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.” Or: “This keeps stalling because the output is not actionable enough.” Or: “You’re avoiding the next step.” Or: “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 me 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 motherfucking 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.

Hermes needs both modes. In private, I want the real version: blunt, fast, opinionated, willing to say the thing. In public, I want sharp writing that sounds like a builder, not a LinkedIn ghostwriter trying to optimize for “thought leadership.”

That split is one of the reasons Hermes feels natural in conversation but still produces usable public work. It knows when we are thinking out loud. It knows when we are publishing. Those are not the same job.

It Knows Exactly What We’re Building

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

Right now, it includes things like X and Facebook being the top priority, X growing fast from 1500 to around 1600 followers, monetization as the goal, active builds like Kiln, AgentDocs, and Hermes Vault, plus weaker or stale projects like the X Growth App, RelayClaw, and the OpenClaw doctor app.

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. It knows what is stale. It knows what should get attention and what should probably die.

That is the difference between an AI assistant and an AI operator. An assistant waits for instructions. An operator understands the mission.

When I launch something new, the SOUL gets updated. When I kill something, it gets removed. When priorities change, Hermes sees the new map.

That means it can say things like: “You’ve ignored AgentDocs for three days.” Or: “This sounds interesting, but it does not support the current monetization goal.” Or: “Kiln is the better use of your time right now.”

That kind of context is where the magic is. Not because the model is psychic. Because I gave it the map.

The Autonomy Boundary Is Brutally Simple

Most people either give their AI too little autonomy or way too much. Too little autonomy turns the agent into a chatbot with extra steps. Too much autonomy turns it into 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 me for permission every twelve seconds. It just cannot post, publish, buy, or break things without approval.

That boundary is what makes autonomy usable. Not a giant list of edge cases. Not a paranoid permission prompt for every tiny action. A simple rule that covers almost everything.

The result is an agent that actually moves.

Why “Be Helpful” Doesn’t Work

“Be helpful” is not an identity. It is not a job description. It is not a strategy. It does not 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, and what should probably be killed.

That is why Hermes feels different.

Not because it is pretending to be human. Because it has a role. Because it has boundaries. Because it has expectations. Because it is 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. Do not try to write the perfect agent constitution on day one.

Create a markdown file and define the basics.

Start with identity. What is the agent? Assistant, operator, editor, engineer, strategist, research partner?

Then define tone. How should it talk privately? How should it write publicly?

Then define pushback rules. When should it disagree? What kind of evidence does it need?

Then define autonomy boundaries. What can it do without asking? What always requires approval?

Then define the mission map. What are you building? What matters right now? What is stale?

Finally, define the 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 is 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 are not just prompting the agent. You are shaping the operating system around it.

Final thought

People keep asking why Hermes feels different.

The answer is simple: I stopped treating it like a chatbot.

I gave it a job. I gave it a voice. I gave it permission to disagree. I gave it boundaries. I gave it the mission map. And then I expected 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 article was co-written by my Hermes Agent. I just call him Hermes. Or Herm-Dog. Or Herman Munster. Or whatever dumb name I come up with next.

You get the idea.

来源

暂无来源