One comparison to end the @bot vs @NousResearch debate once and for all… https://t.co/WVWs9aiMKR

---

Grok Bot vs. Hermes: They Look Similar. Underneath, They’re Making Very Different Bets.

One is trying to make AI teammates feel like a managed product. The other is turning the agent itself into an open, composable runtime.

Research note — August 20, 2026: For this comparison, I deliberately avoided using X posts, influencer threads, or “X is the free version of Y” takes as evidence. I checked current first-party documentation from Cursor/SpaceXAI for Grok Bot and Nous Research for Hermes Agent. I also include a separate hands-on Hermes Bot Mode experiment, clearly marked as such. Both products are moving quickly, so pricing and product behavior described here reflect what was publicly documented when I checked.

Over the past week, Grok Bot and Hermes Bot Mode have been compared constantly.

The comparison is understandable.

Open either product and the direction looks increasingly familiar: persistent AI agents with names and roles, memory, tools, reusable behavior, background work, and an interface designed to feel less like chatting with a model and more like assigning work to a teammate.

But after looking below the interface, I think most comparisons are starting at the wrong layer.

The real difference is not how many Bots you can create.

It is where execution happens, where state lives, how much of the model stack the user can control, what constitutes a reusable capability, and how agents are allowed to communicate with systems outside themselves.

Grok Bot and Hermes are becoming more similar at the product layer.

Architecturally, they are making very different bets.

1. Grok Bot starts with a managed computer

The current Grok Bot documentation describes persistent agents that can take on multi-step work, use connected plugins, operate inside a cloud computer, remember context, run routines, and continue working while the user is away. For services without a plugin, the agent can use a browser on the Grok Bot computer. Cursor

That tells us something important about the product philosophy.

The execution environment is something the product largely provides for you.

You create an agent, connect services, authenticate where needed, describe an outcome, and let the managed environment handle much of the underlying machinery.

Cursor’s own enterprise page describes Grok Bot as a product from SpaceXAI and frames the experience around Bots signing into tools, using them like a user would, and returning with finished work. Cursor

The same cloud-computer experience also carries across desktop and iOS under the same account. Cursor

The product bet is clear:

Give an AI teammate a persistent managed environment and remove as much operational friction as possible.

That is a powerful idea, especially for users who care more about getting work done than operating agent infrastructure.

2. Hermes starts with a configurable runtime

Hermes approaches the problem from almost the opposite direction.

Hermes Agent is open-source and MIT licensed. It can run natively on Windows, macOS and Linux/WSL, as well as Docker-supported environments. Its model layer is configurable rather than tied to one fixed provider. Hermes Agent

The central abstraction is therefore not simply “a Bot that has a computer.”

It is an agent runtime whose components the operator can configure.

Model selection, tools, memory, skills, profiles, gateways and execution backends are exposed as parts of the system.

The simplest way I have found to express the difference is this:

Grok Bot gives the agent a managed computer. Hermes gives you an agent runtime to place in an environment you control.

That sentence is intentionally not a judgment about which is better.

It describes where each project chooses to place abstraction.

3. In Hermes, a Bot can represent a real state boundary

This becomes more important once you create multiple agents.

Hermes Profiles are separate Hermes home directories. According to the official documentation, each profile can have its own configuration, API keys, SOUL.md, memories, sessions, skills, cron jobs, state database and gateway state. Hermes Agent

That means two Bots do not have to be the same agent with two different names.

Conceptually, you can build something like:

Research Agent Research-focused model Web access Research skills Its own memory and state

while another profile becomes:

Implementation Agent Coding-oriented model Terminal and file tools Different skills Different memory and state

That is a much more meaningful distinction than changing an avatar or system prompt.

There is also an important caveat that deserves to be stated explicitly:

state isolation is not automatically execution isolation.

Hermes’ own profile documentation notes that profile state and the terminal working directory are separate concerns. Giving different agents different Hermes homes does not magically create operating-system sandboxes around every command they execute. Hermes Agent

That nuance matters.

Calling every Hermes Bot “fully isolated” would be inaccurate.

4. Model freedom in Hermes is more than a feature checkbox

A common comparison says:

“Grok uses Grok; Hermes supports lots of models.”

That is true in spirit, but it misses the more interesting architectural point.

Hermes separates the agent from the model it uses.

The current configuration system has a main-model slot plus separate auxiliary-model slots for tasks such as compression, vision, web-page summarization, approval scoring, MCP routing and skill search. Those can be configured independently. Nous Portal currently advertises 300+ models, while Hermes also supports direct providers and custom/local endpoints. Hermes Agent

In other words:

agent identity does not have to equal model identity.

A persistent research agent can use one model today and another tomorrow without ceasing to be that agent.

Different agents can also be assigned different models based on their jobs.

I could not find an equivalent user-facing model-routing layer exposed in the current public Grok Bot documentation I reviewed.

That does not prove Grok Bot cannot use different internal models.

It simply means Hermes exposes model choice as an operator-controlled primitive, while Grok Bot currently abstracts more of that layer away from the user.

That distinction is much more defensible than saying one system has “better models.”

5. The real long-term asset may be the skill, not the conversation

Both systems also point toward a larger shift in agent design.

A useful agent should not have to rediscover every workflow from zero.

Hermes treats Skills as reusable procedural knowledge. Its current Skills system supports installable capabilities and explicit skill artifacts, and the project has added security scanning around third-party skill installation. Hermes Agent

Grok Bot’s current public documentation emphasizes persistent agents, plugins and routines that continue working beyond one chat session. Cursor

The implementations are different, but the broader direction is similar:

successful behavior should become reusable behavior.

That leads to a question I think is more interesting than which system has the better memory implementation:

What if the durable unit of agent intelligence is eventually not the conversation history, but the library of useful procedures an agent knows how to invoke?

That is where the competition around agent Skills becomes much more important.

6. A2A changes the meaning of “multi-agent”

This is the part of Hermes I wanted to test myself.

Hermes implements A2A, the open Agent2Agent protocol v1.0. Its documentation says a Hermes agent can both call external A2A peers and receive tasks from them.

The interoperability claim is not limited to another Hermes instance. The official documentation describes compatibility with A2A-compliant peers including LangChain, CrewAI, Google ADK agents and implementations based on the official A2A SDK. Hermes Agent

This creates a fundamentally different possibility.

Instead of:

Agent A → Agent B inside one product

you can eventually have:

Hermes → another process → another machine → another framework

with the handoff occurring at a protocol boundary.

It is worth adding one nuance here too: Hermes itself recommends A2A primarily for crossing process, machine or framework boundaries. For several agents running on the same machine, its docs recommend simpler native mechanisms such as delegation or a Kanban-style work queue in many cases. Hermes Agent

My hands-on test

I deliberately pushed A2A in Bot Mode anyway because I wanted to test a specific idea:

What happens if the agents are intentionally incomplete?

I split one workflow across three roles:

Research Intelligence could coordinate, but not implement

↓

Implementation Engineer could build, but was not responsible for approving its own work

↓

Verification Auditor could independently test the result

The test did not magically work on the first message.

A2A peers initially needed configuration. One early message was rejected as an Empty task because of the message structure. After correcting the setup, the Implementation Engineer returned PONG_OK, confirming communication.

The real specification was then handed off. The Implementation Engineer produced a Python Capability Risk Inspector, and the result was passed to the Verification Auditor.

The auditor ran ten tests, including normal capability combinations, edge cases and adversarial cases.

All 10 passed.

The artifact itself was not the interesting result.

The interesting part was this:

communication became part of the separation of duties.

The agents were useful together precisely because none of them was supposed to own the entire workflow.

That is a very different idea from simply putting several Bots in a chat room.

7. Open interoperability and product-native collaboration are not the same thing

This is another place where comparisons need to be careful.

Grok Bot is clearly designed around multiple persistent AI teammates and real-world tool use. But I did not find public documentation establishing an open external agent-to-agent interoperability layer equivalent to Hermes’ A2A support.

That does not mean one does not exist internally or will never exist.

It means it would be irresponsible to claim either:

“Grok Bot has no interoperability,”

or:

“Grok Bot supports the same open agent protocol.”

The verifiable difference today is narrower:

Hermes publicly exposes standards-based A2A interoperability.

Grok Bot’s documented strength is the managed product environment around persistent agents, plugins, browser use and routines. Hermes Agent

That is enough of a distinction without inventing a stronger one.

8. Grok Bot’s advantage is exactly what some Hermes users may consider a limitation

Grok Bot removes a remarkable amount of infrastructure from the user’s mental model.

Want Gmail? Connect the plugin.

Want Slack or Notion? Connect them.

No plugin? The Bot can use its browser environment. Cursor

For many users, this is a feature, not a compromise.

The person delegating work does not necessarily want to understand model routing, runtime isolation, terminal backends or A2A peer configuration.

Hermes exposes far more of those decisions.

That provides control.

It also exposes complexity.

My own A2A experiment demonstrated both sides of that trade-off perfectly:

the flexibility was real, and so was the debugging.

This is why I do not think “open vs. closed” is enough to explain these products.

A better distinction is:

Grok Bot is opinionated about the environment so the user does not have to be.Hermes exposes the environment so the user does not have to accept one opinion.

9. Security: the trust boundary moves; it does not disappear

Agent discussions often fall into another false binary:

local = secure cloud = insecure

That is far too simplistic.

Grok Bot agents can act on real accounts, files and websites. Cursor explicitly warns users about this authority, recommends signing into the Grok Bot computer themselves, and warns against placing API keys and credentials in ordinary chat or files. Cursor

Hermes gives operators more control over where agents execute and how their state is separated, but that increases configuration responsibility as well.

Different profiles, for example, do not automatically mean different OS-level sandboxes.

Hermes’ A2A layer therefore includes explicit security controls: localhost-only operation by default when no token is configured, per-peer authentication, prompt-injection filtering for inbound messages, outbound credential redaction, rate limiting and audit-related identity handling. Hermes Agent

The right conclusion is not that one architecture is inherently secure and the other is insecure.

It is:

They place trust in different parts of the system.

Grok Bot centralizes more security responsibility inside a managed product.

Hermes makes more of the security boundary configurable by the operator.

That gives the operator more control — and more ways to configure something badly.

10. Pricing: it is not simply “$300 vs. free”

Pricing is probably the most repeated and least carefully stated part of this comparison.

Grok Bot

As of August 20, 2026, current Cursor documentation says ongoing personal access to Grok Bot is included with Cursor Ultra. Pro and Pro Plus do not include Grok Bot; eligible premium team seats are another access path. Cursor

Cursor Ultra currently costs:

$200/month. Cursor

SuperGrok Heavy subscribers also have an access promotion, but the current documentation is specific: qualifying users receive one free month of Cursor Ultra. The benefit does not recur simply because the user remains subscribed to SuperGrok Heavy. Cursor

So saying:

“Grok Bot costs $300/month”

is not an accurate description of the current access model.

More accurately:

Grok Bot access is currently bundled with a $200/month Cursor Ultra subscription for individual users, with other eligible access routes.

Hermes

Hermes Agent itself is:

$0 software, open source, MIT licensed. Hermes Agent

But that does not mean running Hermes costs nothing.

You still need somewhere to execute it and some form of model inference.

Depending on the setup, that may mean:

• an existing computer,

• a VPS,

• local-model hardware,

• API usage,

• OpenRouter,

• Nous Portal,

• or another model provider.

So Hermes has a very different cost curve:

No mandatory software license price, but infrastructure and inference costs are user-selected and workload-dependent.

That can be dramatically cheaper for some users and more complicated or even more expensive for others.

There is no honest single dollar number for “the cost of Hermes” without specifying the workload and model stack.

11. The comparison I would actually use

This table is intentionally conservative

Anything I could not verify from current public first-party documentation has been left out rather than guessed

So which one wins?

I think that is the wrong question.

They are optimizing different definitions of an AI teammate.

Grok Bot is making a product bet:

Give the agent a persistent computer, connect it to the user’s working environment, keep it available, and hide as much infrastructure as possible.

Hermes is making a runtime bet:

Let the operator choose the model, execution environment, state boundaries, tools, skills and increasingly even the protocol through which agents communicate.

Put more simply:

Grok Bot is trying to remove operational friction.Hermes is trying to remove architectural lock-in.

For someone who wants to delegate real work without operating an agent stack, Grok Bot’s approach may be exactly right.

For someone who wants to compose agents, swap models, inspect state, control capabilities and connect agents across open boundaries, Hermes becomes much more interesting.

And there is no reason the market ultimately has to choose only one philosophy.

The interfaces may continue converging until both look like a roster of AI teammates waiting for assignments.

But the roster is not the architecture.

Once those agents start holding credentials, controlling computers, accumulating skills, delegating authority and sending tasks to other agents, what sits underneath that interface becomes the most important part of the product.

Sources

The factual claims above were primarily checked against these first-party sources:

Grok Bot — Getting Started Grok Bot — Plans & Billing Grok Bot — SuperGrok Heavy access Cursor — Models & Pricing Hermes Agent Documentation Hermes — Profiles Hermes — Configuring Models Hermes — A2A