That was one of the first things I asked Hermes.

It feels almost embarrassingly simple compared with the setup I use today.

Now I have several specialised profiles for different parts of my work. There are skills, memory, configuration files, project-level AGENTS.md files, tool assignments and SOUL.md files that define how individual profiles should behave.

The first time I came across some of this, I didn’t even know what I was supposed to put into a SOUL.md.

A role? Rules? Permissions? All of it?

And compared with some Hermes power users I’ve seen, my setup is still fairly small.

If somebody showed me the whole thing on day one and told me I had to understand it before I could start, I probably would have found it pretty overwhelming.

Fortunately, that’s not how I started.

I wouldn’t start with the obvious questions

If you’re looking at an agent system for the first time, these seem like reasonable questions:

• How many agents do I need?

• What profiles should I create?

• Which skills should I install?

• How should memory work?

They’re not bad questions. I just don’t think they’re particularly useful at the beginning.

Each one opens another branch.

Once you start designing profiles, every profile needs a role. Then rules. Then tools. Maybe its own skills. You probably want to test it before trusting it with real work. Before long, you’re doing a lot of fiddly configuration work for a system that hasn’t actually helped you with anything yet.

I think there’s an easier way in.

Don’t begin by explaining to Hermes what kind of agent system you want.

Explain what you’re working on.

Tell it where the relevant documents are. Give it the basic goal of the project. Let it look through the context and ask you about anything it doesn’t understand yet.

Then tell it what keeps annoying you.

Something repetitive. Something you keep having to remember or clean up. Something boring but important enough that you can’t simply stop doing it.

That’s a much more useful starting point than deciding whether you need three agents or seven.

I just started typing

One thing that surprised me early on was how normally I could talk to Hermes.

I wasn’t writing carefully engineered prompts. A lot of my requests were fairly rough.

Sometimes I knew exactly what I wanted. Other times I really didn’t.

In my experience, Hermes was often quite good at looking for missing context on its own or figuring out what it needed before continuing. It sometimes seemed to think around the edges of what I’d actually asked instead of treating my wording as a rigid specification.

That made a big difference for me.

I didn’t have to learn Hermes terminology first and then translate my problem into it.

I could describe the problem in my own words and figure out the terminology later.

The same turned out to be true when my profiles needed improvement.

At first I assumed maintaining them would mean manually going through their configuration every so often and deciding what needed to change.

Now I often just ask the profile itself.

For example, I might start a session with my Librarian and ask something along these lines:

Look through your sessions from the past week. Check what went well and where things became difficult or required rework because the task wasn’t solved correctly the first time.

Give me a clear list of improvements you would recommend and why. Which files or configurations should be adjusted to make your work more reliable?

Don’t change anything yet.

That’s a very different job from me manually trying to guess whether a memory file, skill, rule or configuration needs tweaking.

I still make the decision.

But I can ask the agent that actually did the work to show me where it struggled.

Subscribe now

The moment it started to click

I remember testing this more deliberately when I only had my first few profiles.

I asked one of them whether it knew which other profiles existed and what they were responsible for.

This was mostly a sanity check. Before I let profiles work together, I wanted to know whether the agent actually understood its environment.

The answer looked right.

So I gave it a simple task and asked it to use the integrated Kanban workflow to hand work to another profile the way Hermes was intended to.

I wasn’t completely sure how that was supposed to happen.

Hermes went and checked its own documentation.

Then it did it.

I watched the process in the Kanban dashboard. The task appeared. Another profile was assigned. That profile picked it up and started working on it.

I could follow the steps as they happened, and afterwards I could still see what had happened and who had done what.

That was probably the point where I stopped thinking quite so much about how I was supposed to wire all of this together.

A surprising amount of it was already there.

I still had to decide what I wanted the profiles to do and what boundaries they should have, but I didn’t have to build the underlying way they delegated work to each other from scratch.

Not everything worked perfectly, either.

Early on, my Librarian told me quite plainly that it didn’t have direct Kanban creation tools available in its current toolset.

That was useful too.

Hermes isn’t magic, and I’ve run into things that needed adjusting or a different approach. But that’s quite different from needing to understand and design the whole system before you can get anything useful out of it.

What I would actually tell a friend to do

If a friend installed Hermes tomorrow and asked me where to start, I wouldn’t give them my profile structure.

I’d probably tell them to type something close to this:

That’s enough to start a conversation.

I wouldn’t ask it to build five profiles.

I wouldn’t install a collection of skills because somebody else’s setup uses them.

And I definitely wouldn’t try to design the final architecture.

Give Hermes the project first. Then give it the problem.

Share

“Don’t change anything” is doing more work than it looks

I still explicitly tell agents not to change things when I’m exploring something new.

That might seem redundant. My profiles already have rules in places like SOUL.md and AGENTS.md, and some of those boundaries are defined very clearly.

But during an experiment, I don’t want my confidence to depend on whether I remembered to configure every rule correctly or whether the agent interprets one of them exactly as I intended.

So I say it again in the task.

Don’t change anything yet.

Don’t delete anything.

Show me what you would do first.

Then I decide.

That small boundary makes it much easier for me to experiment.

I can give Hermes access to real project context and ask fairly open questions without immediately handing over control of the project itself.

And I think that’s the part I would have wanted to know when I started.

If you look at my Hermes setup today, you’re looking at the result of many small problems being solved over time.

You’re not looking at the prerequisite.

My first step wasn’t an agent architecture.

It was a normal question typed into a chat.

The rest came when I actually needed it.

I caught myself thinking that more and more while working on ArtMakers, a project I’ve been building for several years.

The problem was usually what came next: where ist it?

I’m using ChatGPT for research, ideas, technical questions, decisions and whatever else comes up around the project. Starting another chat was easy, so that’s what I did.

Within a few days/weeks, there were hundreds of them.

I knew useful information was sitting somewhere in the history. I just couldn’t find it when I needed it the most. A decision I once made might be buried in a conversation from months ago. An idea I wanted to revisit is probably somewhere behind a chat-title that no longer connects to the idea the conversation headed to.

The AI was helping me coming forward with lot of work. Keeping track of the work I had done with AI was becoming a separate problem. A big one, to be fair.

And opening another chat clearly wasn’t going to solve it.

The problem pursued me

Codex improved a different part of the way I worked.

For coding, it made much more sense to use an AI with abilities that could work around the actual project instead of explaining the codebase again inside a normal chat.

So I used it more and more.

Then other things slowly found their way in.

Documentation. Project organization. Administrative tasks. Ideas that occurred while I happened to be working there.

Codex could handle those things very well. That wasn’t really the issue.

I just didn’t want my coding environment to slowly become the place where I ran the rest of the project too.

In hindsight, that sounds fairly obvious. It wasn’t something I had thought much about before.

My way of choosing AI tools had mostly been based on capability. If a tool could do something, why not use it, right?!

Now I was starting to care about something else.

Where should this kind of work actually live?

I had moved some of my work out of ChatGPT, only to begin recreating the same mess somewhere else. That was not as efficient as I hoped it would be before.

That was when Hermes started to make more sense to me.

Share

I thought I’d have to build much more myself

Profiles were probably the first Hermes feature that really convinces me, to give it a try.

I kept discovering that things I assumed I’d have to learn and study myself were already there and working. Profiles could keep their own context. There was a Kanban system. Hermes already knew how to work with built-in plugins, skills, and memory.

I didn’t need to understand all of it before I could just start using it.

That part surprised me. Like, a lot!

From the outside, words like agents, memory, skills and orchestration can make those things sound like something you should understand properly before touching it.

And let me make this as clear as possible here: YOU DON’T!

Most of the time, I simply told Hermes what I was trying to achieve and asked for the available options. I learned what the different approaches as soon as I needed them.

There wasn’t a complex agent architecture at the beginning.

First, there was just one annoying problem.

I kept losing track of things.

So I let it create a librarian

My first important specialized profile wasn’t a developer or an autonomous project manager.

It was a librarian.

Its job was simple:

• look through what I had been working on

• help me keep track of it

• and give me a clearer picture of what was still open.

I had it review my chats in the evening. Together with Hermes’ Kanban board, that gave me something I had been missing for a while: clearance and continuity.

The next day, I didn’t have to reconstruct quite as much from memory.

Ideas were less likely to disappear into an old chat. Open tasks had somewhere to go. I had a better sense of what deserved my attention next.

None of this felt particularly futuristic.

It was mostly just useful.

And once that worked, the rest became easier to think about.

I could create another profile when a different kind of work needed its own context. Coding could stay close to Codex. Organizational work could live somewhere else. I didn’t have to predict the finished system before building the first useful part of it.

There was a practical detail that made experimenting easier too.

Hermes itself is free and open source. In my setup, it can use my ChatGPT subscription I’m already paying for through its Codex integration rather than requiring another Hermes subscription. Hermes also ships with a skill for delegating coding work to the Claude Code CLI, which can use the allowance from an eligible Claude subscription when authenticated that way.

So trying this didn’t mean signing up for yet another monthly AI service before I even knew whether it would help.

That made it much easier to just try it and see whether it was useful.

The part I still don’t hand over completely

The system is more organized now. That doesn’t mean I let AI maintain every part of it on its own.

I learned to be careful with that fairly early.

At one point, information was being treated as something that could be removed because it hadn’t been needed for a while.

I understood the reasoning. I just didn’t agree with it.

An old note might contain an abandoned idea. But it might also contain the reason I abandoned it. Or something I deliberately postponed and want to return to six months later.

So one of the rules became very simple:

Never delete. Only archive.

Of course there are more rules now, and more profiles than that first librarian. Some of them need attention from time to time. I still change things when a setup starts creating more work than it removes.

But that’s not the part I wish somebody had explained to me earlier.

I wish I’d understood how little of the finished system I needed to know before I could start.

I didn’t begin with an agent architecture.

I began with a problem I was tired of having.

I couldn’t find things I had already worked on.

So I gave that problem somewhere to live.

With a librarian.