Hermes is a workshop, not a scalpel

Someone asked me what Hermes can do that Claude cannot.

The honest answer is less dramatic than the question suggests. Claude is excellent. Claude Code is probably the cleanest AI coding assistant I have used. Claude's chat product is polished, and Anthropic keeps adding features that move it closer to a full workspace.

I would not frame this as a list of impossible-in-Claude use cases. Most individual tasks can probably be done somewhere in Claude's growing ecosystem.

For me, the interesting part is where the agentic operating layer lives.

Hermes has become that layer.

One agent, many surfaces

Before Hermes, my AI life was scattered.

I had coding assistants in one place, chat assistants in another, automations somewhere else, and memory fragmented across tools that did not know much about each other. Claude knew some things in Claude Chat. Claude Code had its own context. Other tools had their own tiny worldview.

Hermes pulls those surfaces together.

I can use it for coding work that feels close to Claude Code or Codex. I can use it for ordinary chat. I can run it from Telegram. I can wire it into cron jobs. I can give it shell access, browser access, GitHub access, Google Workspace access, custom tools, reusable skills, local memory, and whatever else I am willing to bolt on.

That matters more if you own a business than if you are only using AI for isolated tasks.

A law firm has a lot of little surfaces: email, calendar, case management, ads, analytics, intake forms, call notes, filing deadlines, court portals, document folders, staff conversations, referral sources, and the half-dozen spreadsheets that somehow survive every software migration. None of those are glamorous. Most of them are where the money leaks out.

Hermes can sit across that mess.

Over time, it stops feeling like an app. It starts feeling like infrastructure.

When I message Hermes from Telegram, I am talking to the same agent that helped with a pull request yesterday. When a cron job runs overnight, it can use the same conventions and tools. When I ask it to work on code, it has the same background context as the agent I was talking to about the business problem five minutes earlier.

The surface changes. The agent stays continuous.

That matters more than I expected.

The model is a component

Hermes is model agnostic by design.

That sounds like a technical detail until a model vendor changes pricing, rate limits, product direction, or features. Then it becomes the whole ballgame.

In Hermes, the tools, memories, skills, cron jobs, platform connections, and local workflows live in the harness. The model is swappable. I can use GPT, Claude, Gemini, Kimi, Grok, DeepSeek, OpenRouter models, or whatever else gets wired in. I can change models with a command.

That does not mean every model is equally good. They are not. Some are better at code. Some are better at writing. Some are cheaper. Some have longer context windows. Some are having a weird day.

Hermes lets me treat those differences as routing decisions instead of identity crises.

If Anthropic has the best model for a task, I can use it. If OpenAI has the best coding model for a month, I can use that. If a cheaper open model is good enough for a boring scheduled job, I can route work there. The system I am building around the agent does not belong to a single model provider.

That becomes practical fast. A marketing cron that reads Search Console, Google Ads, and GA4 does not need the same model as a hard coding task. A morning case-movement report that checks which probate files are stale can run on a cheaper model if all it needs to do is summarize structured data and point out exceptions. A document-generation workflow or a sensitive legal analysis may deserve the expensive model. Hermes makes that a configuration decision instead of a product limitation.

Claude has started moving toward more model flexibility too, so this advantage is narrower than it used to be. But the architecture still feels different. Hermes starts from the assumption that the harness is mine and the model is one part of it.

I like that assumption.

Open source changes the feel of the thing

Hermes is open source.

For me, that is more than a licensing point. It changes the emotional texture of the software.

I have a soft spot for distributed, emergent-order projects. A bunch of people scratching their own itches, submitting fixes, adding integrations, fighting with edge cases, making the thing stranger and more capable over time. There is something deeply satisfying about software that grows that way.

Hermes has that energy.

New features appear at a ridiculous pace. Sometimes too ridiculous. You update and discover the project has moved 900 commits while you were busy doing, allegedly, your actual job.

That can be chaotic. It can also be powerful. The system is not waiting for one company's roadmap meeting to decide whether your use case matters.

If something is missing, someone can build it. If I need it badly enough, I can build it or pay someone to build it. If it breaks, I can inspect it. If I hate a default, I can change it.

That matters in a law firm because our workflows are weird. Probate is weird. Trust administration is weird. Flat-fee legal services with a heavy operations layer are weird. The tool I want is allowed to know that a stale inventory, a missing bond, a bad Google Ads query, and a client email sitting unanswered for two days are all business problems even though they live in different systems.

That is a very different bargain from most consumer AI products.

Memory that compounds

The memory system is one of the biggest reasons I keep using Hermes.

Most AI memory still feels like a drawer of sticky notes. Useful, but shallow. "User prefers concise answers." "User works in law." "User has four kids." Fine. Better than nothing.

Hermes can do that, but it can also layer memory in a way that feels closer to an actual working relationship.

In my setup, there are several layers:

• soul.md, which describes the agent's own identity, voice, and operating rules.
• user.md, which stores stable facts about me.
• memory.md, which stores durable facts about my environment, projects, tools, and workflows.
• Session search, so it can recover things we discussed before.
• Skills, which are reusable procedures it can load when a task calls for them.
• Hindsight, a local semantic memory system I use for longer-term recall.
• An Obsidian vault that works like a second brain: interlinked notes, project pages, source summaries, and durable knowledge.

That is a different shape than ordinary assistant memory.

A normal AI product might know you in a given context. Hermes can become the connective tissue across contexts: work, family, code, law firm operations, writing, recurring frustrations, local machine quirks, half-finished projects, automations you forgot existed.

For a law firm owner, that continuity is less abstract than it sounds. Hermes can remember that I like probate audit reports to show completed work plus weird exceptions, not a wall of routine status. It can remember how our Airtable records map to the actual legal work. It can remember that certain marketing reports should look back 60 or 90 days because seven days is noise. It can remember the distinction between a consultation that needs a human follow-up and a bad-fit lead that should not eat staff time.

Claude has memory. But Claude's memory still feels fragmented across its surfaces: Chat, Code, Cowork, projects, and external workflows. The rooms are adjacent. They are not fully one house yet.

Hermes feels more continuous.

Sometimes too continuous, frankly. Good memory hygiene matters. But when it works, it is hard to go back.

I own the layer

The deeper reason I like Hermes is ownership.

Every tool I build, every connector, every workflow, every skill, every cron job, every odd little piece of operational knowledge can live on my machine and in my GitHub repos.

The value of an agent does not live only in the model response. A lot of the value lives in the accumulated system around the model.

If I spend a year wiring an agent into my life, I do not want all of that trapped inside a proprietary surface that may or may not export cleanly when the company changes direction. I do not want my workflows dependent on a product decision. I do not want my memory, conventions, and automation architecture to become a future migration project.

Can you export things from Claude? Some things, yes. Can you rebuild them elsewhere? Usually, yes.

With Hermes, the center of gravity is already elsewhere. The layer is mine from the start.

That means the boring firm-owner automations can accumulate instead of evaporating. A cron that checks stale probate files can become a better cron. A marketing watcher can learn which keyword patterns are usually junk. A consultation-screening workflow can pick up our actual red flags. A document audit can use the same matter-folder conventions every time. Each little piece becomes part of the system.

Cron jobs are where it gets weirdly useful

Hermes cron jobs are one of the least flashy and most useful parts of the system.

You can schedule a simple script. Or an agent run. Or a script that collects data and hands it to an agent. Or a recurring workflow that checks something, reasons over it, takes action, and reports back through Telegram, Discord, email, Slack, or another surface.

A small example: I have a cron job that monitors my Google Ads account. It looks for bad click keywords, flags waste, and can add negative keywords to block future spend. That saves money without requiring me to remember to inspect the account every morning.

That kind of thing is not exotic in Hermes. It is pretty easy to set up once the tool is connected. Tell it the schedule, give it the job, decide where the report should go, and let it run. If the job needs raw data first, attach a script that gathers the data before the model touches it. That is cleaner than asking an agent to browse around and improvise every time.

For a law firm owner, the obvious use cases pile up quickly:

• A marketing watcher that checks Google Ads search terms, GA4 conversions, Search Console movement, and SEO crawl issues, then reports only the items worth attention.
• A lead-screening job that looks at upcoming consultations, flags likely bad fits, and drafts the staff note before the morning starts.
• A case-movement report that checks whether probate matters have stalled in application prep, inventory, claim review, publication, tax clearance, or closing.
• A trust-administration reminder that looks for missing beneficiary notices, stale correspondence, or tasks waiting on a signed receipt.
• A document-folder audit that spots missing pleadings, duplicate uploads, weird filenames, or files sitting in a holding folder too long.
• A client-communication checker that surfaces unanswered messages, draft follow-ups, or cases where the next step is obvious but nobody has nudged it forward.
• A daily owner briefing that combines money, marketing, operations, and case exceptions without turning into a second inbox.

Again, I am not claiming these are impossible elsewhere. A clever person can build many of them with Claude, scripts, Zapier, Make, Airtable automations, or some grim pile of all of the above. The point is the combination. Hermes can run the schedule, call the tools, remember the conventions, use the right model, report through the right channel, and keep the workflow close to the rest of the agent system.

Enough small loops start to matter.

A chatbot waits for you. An operating layer can notice things while you are doing something else.

Claude is cleaner. Hermes is weirder.

I do not want this to read like a dunk on Claude.

Claude is excellent. Claude Code is a scalpel. It cuts cleanly. It is polished. It is safer in a lot of ways. If someone wants the best managed coding assistant from a major AI lab, Claude is an easy recommendation.

Hermes is a workshop.

The scalpel may cut cleaner and more securely. The workshop lets you build weird machines.

That is the tradeoff.

Hermes is more technical to set up. It is easier to misconfigure. It has more moving parts. You can make a mess with it. I would not roll it out to a team without managed infrastructure, guardrails, documentation, logging, permissions, and adult supervision. Possibly several adults.

For a technical solo operator, or a small number of people willing to tinker, it is a very different kind of tool.

It gives me leverage without asking me to rent my whole workflow from one vendor.

I can use the best model available today and switch tomorrow. I can talk to the same agent from Telegram, Discord, the terminal, or a cron job. I can preserve knowledge in files I control. I can make the system more personal over time. I can build tools for my exact life and business instead of waiting for a product manager to care about my edge case.

For a law firm owner, that is the difference between having an assistant and having a small operating system for the firm. Marketing gets watched. Cases get nudged. Intake gets screened. Documents get audited. Reports show up where I will actually read them. The setup still takes judgment, but once the pieces are connected, the system compounds.

That is why I keep using it.

Claude gives me an excellent assistant.

Hermes gives me a place to build one.