DEV Community

Hemapriya Kanagala
Hemapriya Kanagala

Posted on

Your Tools Don't Learn You. This One Does.

#hermesagentchallenge #devchallenge #ai #agents

Hermes Agent Challenge Submission

This is a submission for the Hermes Agent Challenge

TL;DR
Most AI agents forget everything the moment your session ends. Hermes Agent is built differently, with a learning loop at its core that creates skills from experience, improves them during use, and builds a picture of you over time. The longer you use it, the better it gets at working with you specifically.

Estimated read time: ~8 minutes

Table of Contents

Wait, Think About This First

Okay so I want to ask you something before we get into anything.

How long have you been using your code editor?

A year? Three? More?

Now here is the actual question.

Is your editor any better at working with you specifically after all that time?

Does it know how you structure projects? Does it know which patterns you reach for at 11pm when you are tired and just want something to work? Does it know anything at all about you as a person?

No.

It is exactly the same editor it was on day one. You learned it. It did not learn you back.

And the thing is, we have just accepted this. For as long as software has existed, this is how the relationship works. The tool stays the same. You do all the adapting. You learn the shortcuts. You write the snippets. You configure everything. You are the one who changes.

The software never does.

I want to talk about why that might be changing, and why Hermes Agent is one of the more interesting things I have come across in a while.

The Goldfish Problem

Before getting into what Hermes Agent is, I want to describe a thing that happens with almost every AI agent right now.

You open it. You start working. You have a productive session where things all come together and the agent figures out your context and you feel like you are finally getting somewhere.

Session ends.

You come back the next day.

The agent has absolutely no idea who you are.

You explain your project again. Your preferences again. The decision you made last week that the agent helped you reach. All of it, again.

This is what people in the AI field call being "stateless." When the session ends, everything goes away. No memory of what worked. No memory of you. Clean slate every single time.

For quick one-off tasks this is totally fine. You are not asking the agent to know your life story just to explain a concept or summarize a document.

But for ongoing work? For projects you come back to every day? For workflows that are genuinely specific to how you operate?

It gets old fast.

And here is the thing that gets me.

We accept this from AI agents in a way we would never accept it from an actual person.

Imagine hiring a contractor to help renovate your house. They show up day one, learn everything, do great work. Day two, completely different person, never heard of you. Day three, another new one.

You would not keep that contractor.

But somehow with AI agents we just... shrug and re-explain ourselves every single day.

Okay, What is Hermes Agent?

Hermes Agent is an open source AI agent built by Nous Research. If you do not know Nous Research, they are the team behind the Hermes model family and have been in the AI space long enough to have a real track record.

On paper it does what you would expect from a capable agent. Tool use, terminal commands, web browsing, code writing and execution, long complex tasks. You can talk to it through Telegram, Discord, Slack, WhatsApp, and about 20 other platforms. Runs on your own machine.

All of that is fine and good.

But then I noticed this.

Hermes Agent was built around a completely different assumption than most agents.

The assumption is: an agent that runs over time should actually get better over time.

Not because the underlying model gets an update. Better because it is learning from your sessions, building on what it figured out, and accumulating something real the longer you work with it.

That is a different idea. That is the software learning you back.

The Learning Loop, Without Making It Complicated

Hermes Agent calls this a closed learning loop. 4 things happen inside it.

Skills built from experience
When Hermes Agent figures out a good way to handle something specific to your work, it does not just do the thing and move on. It can package that into a reusable skill. An actual callable piece of capability it can reach for again next time.

So the more you use it, the more it has built up around your specific context. Your codebase. Your workflow. The kinds of problems you actually deal with on a Tuesday afternoon.

Skills that improve while being used
This one is the part that sounds a little too good to be true when you first hear it.

When the agent uses a skill and notices something that could work better, it updates the skill during the work. Not after. During.

Think of someone who, while doing a job, improves the way they do the job at the same time. Both happening at once. That is what this is.

The nudge system
Small thing. Actually matters a lot.

Left completely to itself, an agent might figure something useful out in a session and then just not bother storing it anywhere. The moment passes. Gone.

Hermes Agent has a mechanism that actively asks itself: is this worth keeping?

That push toward persistence is the difference between an agent that could remember and one that actually does.

A model of you that builds over time
This one has a name that sounds like a research paper: Honcho dialectic user modeling.

Plain language version: every interaction teaches the agent something about how you specifically work. Your preferences. Your patterns. What you care about and what you do not. How you like things explained.

Over time this becomes an actual picture of you. Not developers in general. Not your job title. You.

And this is different from writing a system prompt where you describe yourself manually. A system prompt is static and only knows what you remembered to tell it. This updates from experience. The agent notices things you never explicitly said.

Is It Just Hermes Agent Doing This?

No, and that part matters.

A few teams are working on agent memory and continuity seriously right now.

MemGPT, now developed under the Letta platform, is specifically built around persistent memory. They have thought carefully about what agents should keep versus let go.

LangGraph from LangChain is working on stateful agent workflows, giving developers control over how context carries between steps.

Anthropic has added memory features to Claude. OpenAI has memory in ChatGPT now too.

So this is not a problem only Hermes Agent noticed. Other people are thinking hard about it.

The difference is that Hermes Agent is fully open source, runs on your own machine, and the learning loop is not something added on top of an existing agent. It is baked into how the agent fundamentally works from the start.

That is a meaningful difference.

Oh, and the Skills Are Shareable Too

One more thing and then I will get to the practical stuff.

Hermes Agent connects to a community skill ecosystem at agentskills.io. Skills are portable and shareable between users.

So when someone in the community figures out a really reliable approach to a complex workflow, they can package it as a skill and share it. You install it and your agent has that capability without needing to figure it out from scratch.

And because skills improve during use, a skill you install can get refined through your own sessions over time and slowly fit your specific context better than when you first got it.

It is open source thinking applied to agent capabilities.

Someone builds something useful. It gets shared. It keeps getting better as more people use it.

What This Changes Day to Day

Concrete example because "the agent learns" is easy to say and hard to picture.

Say you use an agent to help review code every day. You have opinions. You care about specific things, maybe how errors are handled, or whether edge cases are covered, or particular patterns your team uses. Other things matter less to you.

With a regular stateless agent you explain your preferences at the start of every session. Or you have a long system prompt that tries to capture everything, and you hope you remembered to include the important stuff. It works but it is overhead you carry constantly.

With an agent that builds on your sessions, something different starts happening after a while.

It knows what you care about.

It has skills built around your codebase specifically.

It remembers the decisions you made last week and applies the same reasoning without being reminded.

You stop re-explaining yourself.

That overhead that you did not even notice because it was just how things worked starts to quietly disappear.

Getting It Running

One line.

Linux / macOS / WSL2:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
Enter fullscreen mode Exit fullscreen mode

Windows (PowerShell):

iex (irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1)
Enter fullscreen mode Exit fullscreen mode

Android via Termux:

Same curl command as Linux. The installer detects Termux automatically.

After it finishes, pick your provider:

hermes model
Enter fullscreen mode Exit fullscreen mode

Works with OpenRouter, Anthropic, OpenAI, Hugging Face, and several others. Free tier options exist so you can try it without spending anything upfront.

Then just start:

hermes
Enter fullscreen mode Exit fullscreen mode

Or the newer interface:

hermes --tui
Enter fullscreen mode Exit fullscreen mode

First time it responds and just works, running entirely on your own machine, it does feel a little different from opening another browser tab.

The Bigger Thing Underneath All Of This

I want to end on something that I keep coming back to.

We have spent decades building the assumption that software stays static and users do all the adapting. You learn the tool. The tool does not learn you. That is just how it works.

Your text editor has been the same relationship since the beginning. Your terminal. Your browser. Your IDE. Every tool you use. You poured time into learning them. They gave you capability in return. But the relationship only ever went one direction.

You changed. The tools did not.

Hermes Agent is built on a different assumption. The agent adapts. The agent accumulates. The agent compounds over time.

An agent you have been using for 6 months is different from an agent you started today, because 6 months of your actual work went into it. Skills built from your sessions. A model of you built from your interactions. Capabilities refined around your specific context.

Your text editor cannot do that. Your terminal cannot do that. Almost nothing in your development environment can do that.

The relationship between a developer and their tools has been one-directional for a very long time.

This is one of the first real cracks in that.

References

For a deeper look at Hermes Agent and the ideas mentioned in this post:

🤝 Stay in Touch

Place Find me here
GitHub building things → hemapriya-kanagala
LinkedIn resources & updates → hemapriya-kanagala
X random dev thoughts → @KanagalaHema

And seriously, if something here made sense (or didn’t), drop a comment.

Top comments (0)