How to Make Hermes Agent More Reliable (Without Adding More Tools)

What Actually Makes an AI Agent More Reliable

Adding more skills, more tools, and more memory does not make an AI agent more reliable. It makes it slower and harder to trust, because you still have to check its work. Reliability comes from three specific upgrades, done in a fixed order: verification that catches silent failures, an approval gate for anything with money or public actions attached, and sub-agents with restricted tool access so speed does not come at the cost of safety.

I run a Hermes agent that reads my inbox, finds the best opportunities, and answers them. Last week it added $10,000 to my business. It got there not because I gave it more skills, but because I took skills away and fixed how it reported on itself. Here is the full breakdown, with the exact instructions I use.

Why More Skills Made My Agent Worse

There are three numbers that decide whether an agent is actually useful to you:

1. How much work it does.
2. How much you trust what it does.
3. How much happens without you checking it.

These numbers do not add. They multiply. If you trust half of what your agent produces, doubling its workload does not give you an employee. It gives you a second job, because you now have twice as much to inspect.

For months I raised only the first number. More skills, more tools, more memory. Trust stayed flat. So every upgrade just created more work for me to verify by hand. Call the second number the trust line. Everything above that line comes straight back to your desk, no matter how much work the agent attempted.

The fix is not doing less. It is raising the trust line first, then adding capability on top of it. That order matters more than anything else in this article.

Upgrade 1: Stop the Silent Failure

The first time I ran my inbox agent, it told me it had sent nine replies. It had sent zero. Nothing errored. Nothing turned red. The agent finished, said it was done, and moved on. I only caught it because I went looking.

This is the actual problem with agents right now. It is not that they are dumb. It is that a language model cannot always tell the difference between doing something and saying it did something. It judges itself on intent: it followed the steps, so it reports success. You need it to judge itself on the artifact instead.

Four things fixed this for me:

1. A closing line in every skill. I now end every skill file with this exact instruction:

Before you tell me this worked, open what you produced and check it
against what I asked for. If you cannot open it, you did not do it.
Report what you actually found, not what you intended.

That single line forces a check against the real output instead of a summary of the attempt.

2. Code over instructions wherever there is exactly one right answer. A model does not run your instructions. It reads them and improvises through them, every time. I tested this by asking my Hermes agent, in three separate threads, how much to charge for a dedicated YouTube video. I got three different numbers: $4,000, $6,000, and $4,500. Same question, same agent, three answers. Anything involving a number now lives in a script, not a prompt. Two benefits come from this: the output is identical every time, and the script never gets loaded into context, so it is cheaper and more reliable at once.

3. Preconditions before the task runs. My inbox skill depends on things it does not control: an inbox connection, a pricing file. Left alone, if either is missing, the agent does not stop, it improvises around the hole. Now the skill checks first:

can_reach_inbox()      -> must return true
pricing_file_exists()  -> must return true
pricing_file_is_current() -> must be from this month

If any check fails, it stops and reports the failure instead of guessing a number.

4. Hooks that catch silent failure inside a minute. Hermes lets you run custom code at certain moments in a job. My rule: if a job finishes and produced nothing, that is not a success, that is a silent failure, and I want to know inside a minute, not the next time I happen to check.

Upgrade 2: The Approval Gate That Creates Autonomy

Most people treat approval gates as a brake. Something you add later, once you trust the agent more. That framing is backwards. The gate is what lets you leave your desk in the first place.

Without a hard line the agent will not cross, you have to watch everything it does, because it could do anything. That is not autonomy, that is a slower version of doing the job yourself. Once the line exists, everything on the safe side of it can run without you.

For my inbox replier, the line is money. The agent can answer questions, book a call, send information, ask for details. The moment a reply would name a price, commit to a date, or promise a deliverable, it stops and waits for me. That happens on roughly one message in eight. The other seven run without me, and I never wake up to something I did not agree to.

Two details make the gate actually work:

• It runs where you already look. My agent runs every morning at 9am as a cron job and delivers into Telegram, not into a log file I would never open. Work sitting in a log is work that did not happen, because you will not go read it.
• Rollback is on. Hermes takes a snapshot before it changes files, and you can revert to it. Almost nobody turns this on. It is free. The gate makes leaving safe. Rollback makes acting safe.

Upgrade 3: Sub-Agents, and the Difference Between a Rule and a Wall

For a long time my agent did everything sequentially: read the inbox, research the sender, check history, draft a reply, one step after another. It was slow.

Sub-agents fixed the speed problem, but the part everyone misses is what they do for safety. When you delegate to a sub-agent, that child gets its own context and only the tools you explicitly give it. My email sub-agent reads the inbox and sorts it. That is all it can do. It cannot send anything. It cannot write files. It cannot spend money. Not because I told it not to. Because it does not have those tools.

That is the difference between a rule and a wall. A rule is a sentence in a file that a model might follow. A wall is a tool that is not there. Sub-agents let you get speed from parallel work and safety from restricted tools, from the same design decision.

The Context Tax Nobody Talks About

Every skill you have enabled costs you before you type a single message. The name and description of every enabled skill loads at startup so the agent knows what it can reach for. That is a tax on every message, every sub-agent call, every scheduled run, forever.

My biggest skill alone is 21,000 tokens. I am not proud of that. So I turned off everything I do not actually use. Not deleted, turned off. The floor came down and everything above it got faster. If I were starting over, I would keep six skills I use daily and leave the rest off until I actually needed them.

The 30-Second Audit You Can Run Right Now

This is the check I promised. Paste this into your agent:

Count every skill I have enabled. Add up the tokens in all their
names and descriptions and tell me how much context that cost me
before I typed anything. Then list every skill I have not used in
the last 30 days.

The second list is the interesting one. When I ran this, I found skills I had been paying context and latency for, for weeks, without using them once.

Mistakes I Made, So You Don't Repeat Them

1. Adding a skill because it looked cool. Every enabled skill is rent. I have deleted more skills than I have kept, and the agent got better every time.
2. Letting an agent take a financial or public action without a gate. No agent of mine names a price or commits to anything without stopping first.
3. Trusting a success report from anything that cannot show me what it produced. This was the mistake I made the longest, and it is the one that cost me the most silent failures.
4. Doing the three upgrades out of order. Speed on top of an agent you cannot trust does not give you more output. It gives you more mess arriving faster. Verification first, then the gate, then sub-agents.

What to Do Next

Do not add another skill this week. Instead:

• Add the closing verification line to every skill you have written.
• Draw one hard line for financial or public actions, and make the agent stop there.
• Run the 30-second audit prompt above and turn off anything you have not touched in a month.
• Only after those three are in place, look at sub-agents for speed.

The agent that made me $10,000 last week is not smarter than the one I had six months ago. It runs fewer skills, not more. What changed is that I can predict it. It tells me when it fails, it stops before anything that matters, and it does not need me to start it.