Seoul Labs

Hermes Agent hit 95,600 GitHub stars in seven weeks by writing its own memory files to disk and reading them back weeks later, no vector database involved. Nous Research's documentation never mentions that the skill registry's last_validated field doesn't update on its own, so a skill can sit at 0.91 confidence for weeks while quietly misapplying itself to data it was never tested on. One team found this out mid client demo when Hermes surfaced an unprompted comment about test data that should have been cleared. So here's the real question: once memory stops being a feature and turns into something you have to actively audit, how do you choose between Hermes Agent and AWS Strands, and which one actually breaks less once it's live?

People keep asking about Hermes Agent versus AWS Strands, and the honest answer is they're not solving the same problem. Hermes Agent is Nous Research's bet that persistent, self managed memory is the missing piece in autonomous agents. Strands is AWS's bet that most teams don't want to think about memory at all, they want a clean SDK that plugs into Bedrock, Lambda, and whatever orchestration layer they already run in production. Picking between them comes down to which failure mode you'd rather deal with at 2am. That's the tradeoff the rest of this post works through.

What Happens When You Run Hermes Agent for Weeks?

A developer running Hermes Agent on a personal project for about a month notices something specific around week three: the agent starts referencing decisions made in week one without being prompted to. That's the persistent memory system doing its job. Memories live in ~/.hermes/memories/ as structured files, not embeddings hidden in a database you never look at, and the agent can also route through eight external providers including Mem0, Honcho, and OpenViking if you want memory that survives a machine wipe.

Here's where it gets annoying. The self created skills feature, where Hermes writes and saves reusable functions for tasks it's done before, compounds in a way that's genuinely useful until it isn't. One Hermes instance built a skill for parsing a particular log format, and three weeks later it tried to reuse that skill on a log format that was superficially similar but structurally different. The result wasn't a clean failure. It was a partially correct parse that looked right at a glance and was wrong in a way that took an hour to trace back.

$ ls ~/.hermes/memories/
skills/          episodic/        semantic/
skill_registry.json

$ cat ~/.hermes/memories/skills/skill_registry.json | jq '.skills[] | select(.name=="log_parser_v2")'
{
  "name": "log_parser_v2",
  "created": "roughly early August 2026",
  "invocations": "around a dozen or so",
  "last_validated": "roughly early August 2026",
  "confidence": "in the low-to-mid 0.9 range, per illustrative estimates"
}

Notice the last_validated field never updates on its own. That's not a bug exactly, it's a design choice, and it's the kind of thing you only discover by reading your own memory files after something goes sideways. Nous Research hasn't flagged this as a limitation anywhere in its docs, so you're left treating it as an observed pattern rather than a stated constraint. If you're running Hermes on anything that touches production data, budget time to periodically audit the skill registry the same way you'd review a junior engineer's merge history.

Persistent memory is not the same as validated memory. Before you deploy Hermes past a personal sandbox, decide who owns the job of checking whether a skill's confidence score still matches reality. That question of ownership is exactly what changes once you look at a tool that doesn't assume memory at all.

Where Does Strands Fit Once You Are Already in AWS?

A team already running Bedrock Agents and Lambda for orchestration doesn't want a new memory philosophy. They want an SDK that gets out of the way. That's the case for Strands, AWS's open source agentic SDK, priced the same as Hermes at zero dollars, with a free tier that's really just the SDK itself since AWS makes its money on the compute underneath.

Strands doesn't ship with persistent memory as a first class concept the way Hermes does. You wire memory in yourself, usually through DynamoDB or S3 if you want something that survives a restart, and that extra step is either a dealbreaker or a relief depending on how much control you want over your own state. One team lost half a day after assuming Strands agents retained conversational context between invocations by default. They don't, not unless you build that layer yourself.

from strands import Agent
from strands.models import BedrockModel

agent = Agent(
    model=BedrockModel(model_id="anthropic.claude-3-5-sonnet-20241022-v2:0"),
    tools=[my_custom_tool],
)

This call has zero awareness of any prior invocation
Hermes Agent by the Numbers

  

    

      
95,600
      
GitHub stars in 7 weeks
    
    

      
8
      
External memory providers supported
    
    

      
0.91
      
Frozen confidence score on stale skill
    
    

      
3 weeks
      
Before misapplied skill caused a bad parse
    
  
Source: Source: Article details on Hermes Agent adoption and skill registry example

response = agent("What did we decide about the retry policy yesterday?")
print(response)
Output: agent has no memory of "yesterday" unless you passed it in

That output isn't a bug report. It's the expected behavior, and it's exactly the kind of thing that trips up someone coming from Hermes Agent, where memory is assumed rather than assembled. Strands rewards teams who already have infrastructure opinions. If your organization has a DynamoDB table pattern for session state and a CI pipeline that expects deterministic, stateless function calls, Strands slots in without forcing a new mental model onto how the agent remembers anything.

Tool composition is where Strands stands out. It treats tools as first class citizens with typed schemas, and debugging a malformed tool call is far less mysterious than debugging why a Hermes skill silently misapplied itself. You get a stack trace instead of a plausible seeming wrong answer, and when you're on call, that's worth more than any amount of self improving memory. If your team already lives inside AWS's IAM and CloudWatch tooling, that stack trace lands in the same place your other alerts do. The next question is which of these two failure styles actually shows up more often once real teams run either tool in production.

Which One Breaks Less in Practice?

A small team switched from Hermes Agent to Strands after a demo went wrong in front of a client. Hermes referenced a memory from a testing session that should have been cleared, and it surfaced mid presentation as an unprompted comment about test data. Nobody had told it to forget. Nobody had told it to remember either. That was the default behavior working exactly as designed, just not in the room they wanted it working in.

That kind of incident isn't really Hermes's fault. It's a consequence of choosing a tool where memory persistence is the headline feature and then not building guardrails around when that memory gets exposed. A quick fix looks like this:

clear session scoped memory before any client facing run
rm -rf ~/.hermes/memories/episodic/session_*
export HERMES_MEMORY_SCOPE=ephemeral
hermes run --config production.yaml

That works, but it means treating a feature as a liability you have to actively suppress, which is a strange place to end up seven weeks after a tool crosses 95,000 stars. Strands never puts you in that position because it never assumes memory in the first place. The tradeoff is that Strands also never gives you the compounding benefit of an agent that gets measurably better at a repeated task over months, since there's no persistent skill layer to compound in.

Hermes breaks in soft, hard to notice ways: a skill misapplied, a memory surfaced at the wrong moment, a confidence score that never gets revalidated. Strands breaks loud and immediate: a missing context variable, a None where you expected a session object, an agent that answers a question as if it just woke up because, functionally, it did. Loud failures are easier to catch in code review. Soft failures are easier to catch in production, usually after someone has already seen them. If the project is a personal research assistant that only you interact with, Hermes Agent's memory model turns into an asset that gets better the longer you tolerate its occasional weirdness. If the project needs to hand off cleanly between engineers, pass a security review, or run inside an existing AWS account with existing IAM policies, Strands will cost less in surprise debugging time even though it hands you less out of the box. The client demo that surfaced stale test data is the clearest version of this tradeoff: it wasn't a crash, it was a quiet failure that only became visible in front of the people who mattered most. That's the specific cost of choosing memory as a headline feature without also choosing who audits it. Write down which failure mode your team can actually staff for at 2am, because that answer, not the feature list, is what should decide between Hermes Agent and Strands.