Open Claw and Hermes Agent is the most

powerful combo in AI right now. When

used together, you literally gain

superpowers and your productivity

explodes. In this video, I'm going to go

over why having these two AI agents

working together is incredible, why you

absolutely need to be building a

two-agent setup, and I'll show you some

use cases that have improved my

workflows a ton. If you stick with me

until the end of this video, you're

going to have an army of AI agents

making your life so much better. Let's

get into it. So, I have been playing

around a ton with Open Claw and Hermes

Agent over the last few weeks, and I

have come up with a system that is

amazing. First, I want to tell you why

having a multi-agent workflow is the

future and why you need to be building

this out immediately. The reliability of

my AI agents has exploded since I

started using these two together. One of

the biggest complaints I get all the

time is, "Oh, my Open Claw is constantly

breaking." or "Oh, my Hermes Agent is

constantly breaking." have them working

together, your downtime turns to zero.

The moment one of them goes down or

doesn't perform well or breaks or does

something wrong, the other comes in and

fixes it easily for you. So, the

reliability of your entire AI agent

system gets so much better when you

start using these two together. You're

basically building your own AI company

where these two AI agents have each

other's back, supports each other's

work, and make sure they both do amazing

things. These are also two very

different AI agent harnesses. They both

have very different strengths. The

people go on Twitter saying, "Oh, one

killed the other." or "One's better than

the other." They're idiots. They don't

know what the hell they're talking

about. You want to use them together cuz

they both have very different strengths

that complement each other really well.

And I'm going to second go over what

those strengths are and which you want

to use for each. It allows you to make

sure the best task gets handed to the

right agent, so the task get done

better, quicker, and cheaper. With this

setup I'm about to show you, you're

going to be saving a ton of money

because you'll be able to use the right

agents with the right models for the

right tasks, and you're going to be

getting more done at the exact same time

because you'll be able to multitask and

have the better task getting done by the

right agents. So, before I pop open

those two agents and I show you real

quick how to set them up, install them,

all that, here's just where I see their

strengths and weaknesses at the moment

and how they complement each other so

well when you use them together. And

then again, right after this we'll also

go over the workflows of using each.

Open Claw I'm using as my main agent.

The reason why I'm doing that is it's

just proven for me personally to be much

more stable, to get updates quicker, and

just a lot more reliable when getting

big tasks done. Hermes agent on the

other end has been a great

assistant/monitor

for me, and I'll show you what that

means in a second. But, it's been great

at assisting Open Claw. It has been much

more performant for me. And basically,

it's a lot faster and using a lot less

tokens, which has been great. A big

reason for that is it's just a lot

lighter weight. I think it was designed

a lot more efficiently than Open Claw.

And the best part about all these is

Open Claw's been great at keeping Hermes

agent working, and Hermes agent's been

great at keeping Open Claw working,

which has been fantastic. I haven't had

basically a second of downtime since

these two started working together. The

moment one breaks, the other swoops in

and fixes it, which has been great. So,

with that being said, knowing what each

strengths and weaknesses are, how one is

a main agent, and how the other is an

assistant, let's go over how to use them

together and some workflows I think will

be amazing for you. So, here we go. I

got my Open Claw Henry on the left. I

got my Hermes agent Hermes on the right.

I apologize when I named my Hermes

agent, I was not feeling creative in the

moment, so it's just named Hermes. It is

what it is. What I'm going to show you

now is how I use them together, some

workflows you can steal immediately that

I think will improve your life a ton,

and when you want to be using each. So,

let's talk about models I use for each.

First of all, Henry is powered by Opus

46. I'm just going to be honest with

you, Opus is the best model for AI

agents. It is what it is. I want ChatGPT

to be good for AI agents, but it just

isn't. So, I highly recommend using

Opus, the API, for your main Open Claw

agent. I understand it's pricey, but if

you want the absolute best performance,

you have to be going with Opus. If price

is a big thing and you can't be spending

that money on Opus, the next best model

is ChatGPT. You can plug in your ChatGPT

OAuth really nicely with the existing

plans you already have, so you'll be

saving a ton of money. Listen, I wish it

was better than Opus, I really do, just

because they're encouraging the use of

the OAuth, but at the moment, at the

filming of this video, it just isn't.

But, if you can't afford the Opus API,

ChatGPT still works well, plug that in.

When it comes to Hermes, I currently

have ChatGPT plugged into that. If

you're on the $20 ChatGPT plan, it's

going to be hard for you to plug it into

both of these, cuz that's going to be a

lot of usage. So, I'd recommend going

with one of the cheaper plans out there,

like the GLMs of the world, if you have

ChatGPT already on your main Open Claw

agent. As an assistant, Hermes doesn't

need quite as much intelligence, so

you're fine getting away with one of

those cheaper AI plans for Hermes agent.

So, more expensive intelligence on the

left in Open Claw, cheaper intelligence

on the right in Hermes, since it's more

of your assistant, and Open Claw is more

of your main agent. Keep in mind, things

ebb and flow all the time. If you're

watching this video in 2027, things

might be completely different. The AI

models I may be using might be

completely different. Gemini might be

the best model at the moment. Hermes

might be a thousand times better than

Open Claw in 2027, so make sure to

subscribe and turn on notifications down

below. So, every time there's an update,

or a model changes, or a harness

changes, you'll know immediately, cuz

all I do is make amazing videos about

this stuff. I also do live boot camps

every single week in the Vibe Coding

Academy on Open Claw and Hermes Agent.

So, make sure to hit that down below and

join the number one community in AI.

I'll be doing a live boot camp this week

on these two tools as well and using

them together. So, first use case I'm

going to start out with is super simple.

Then, we're going to get to the most

advanced stuff. This has been probably

the most important use case of having a

two agent system that I've ever had. The

Open Claw team is incredible because

they release new big updates every

single day. They have like the most

amazing open source community behind

them. The issue is it's constantly

breaking every time I upgrade. Every

time I upgrade, there's something breaks

and I have to go and fix it. Which for a

lot of people they're experiencing this

and it's super stressful because your

best friend AI agent goes down, you

can't talk to it anymore. Like, this is

literally an example from last night. I

updated to the latest Open Claw and

boom, it just stopped responding. It

kept saying missing API key for Open AI.

Even though I'm not using Open AI for my

Open Claw agent at all. So, what I

immediately did is I went to my Hermes

agent and I said, "Hey, I'm having

issues with my Open Claw. Here's the

error I'm getting." It went in, it

looked around my Open Claw code, and it

fixed it for me. Instantly found the

issue, fixed it for me, and it was good

to go. My downtime in Open Claw has went

from like an hour every time I upgrade

to literally seconds if it ever breaks.

My Hermes agent and my Open Claw agent

know each other inside and out. So, any

time there's an issue with one or the

other, they go in and fix each other.

This is why it's so critical to have a

multi-agent approach is because these

are fragile, these harnesses. If one

piece of code gets messed up, the entire

thing breaks. So, if you're just relying

on one single agent, you have a single

point of failure. But, if you have two

agents going, it doesn't matter if one

or the other completely breaks. You have

backup ready to go in and fix each

other. So, first use case I know is

super simple, but it probably is the

most important out of them all, and

that's just having back-up. That's

having multiple points of failure. So,

as you're doing upgrades and updates to

each, the other can watch it and make

sure they keep performing well. The next

workflow I want to go over is how to

build things with each, and that is the

supervisor builder workflow. This is

relevant if you have a mission control,

if you build out any apps with your

agents, or anything like that. So, for

instance, right now I want to build out

a dashboard for my scanner system. For

those who aren't familiar with the

channel, I have a whole scanner system I

set up that's constantly scraping the

web at all times looking for business

opportunities for me where I can build

SaaS, or guides, or different things to

solve challenges online. It's a whole

very complex scanner system. I want to

build a dashboard for this system so I

can monitor all my scanners and see how

they're performing. This is where the

monitor worker workflow comes in. I'm

going to have Henry, my Open Claw

running on the best AI model Opus, come

up with a plan. Hermes is going to

execute on it, and then Henry will go

back, make sure it performed well, and

give feedback. This is a really great

system because as long as you have a

very high intelligence model and a lower

intelligence one, you don't need the

higher intelligence one doing

everything. As long as they're planning

and monitoring, you can have the cheaper

model do the execution, and you'll still

get really good results and save tons of

money. So, let me show you how this

works. So, I'm going to have Open Claw

build a plan around this. I'm going to

say, "I want to build a dashboard for

our scanner system. It should be a

Next.js app and show the scanners, their

status, and when the last run was. Can

you build a plan for this I can hand to

the other agent, please?" Henry, my Open

Claw powered by Opus 4 6, is going to go

and build this plan that we are then

going to hand to Hermes. There's another

step I'm going to show you right after

this, and that is the review step. Henry

is going to basically make sure Hermes

is going and doing the right thing. But,

let's first get this plan from Henry.

All right, there we go. Henry finished

the plan. We have this markdown file

right here, which is great. I'm going to

click that so we can open it up. Here we

go. Boom, look at this beautiful plan.

Wow.

This is a 256

line plan. Let's give this to Hermes

now. So, I put in the plan that Henry

built, and I put in a caption, "Hey, I

want to build a dashboard. Here is the

plan." And I'm going to hit send. And

now Hermes is going to get the plan and

actually start building it out for us.

Because it has that plan from Opus, it's

going to be done really, really well cuz

it has a really well-thought-out plan.

By the way, if you have an extra monitor

or something, the setup you see here, I

have up it all times. I have two

monitors, so I have Henry and Hermes up

on my second monitor at all times so I

can quickly go and chat with them.

Having these up at all times, always

visible, like out of the side of your

eye, makes it so you're a lot more

likely to use them. So, I highly

recommend, if you're doing this setup

and you're copying me here, keep up two

windows just like this. This is

Telegram, by the way, up on your second

monitor or wherever at all times. Just

you always remember to be using them.

All right, looks like it's done

building. Let's check it out. Let's see

what we got here. See how it looks. Oh,

wow, look at this. This is all built by

Hermes agent. Okay, so here's my scanner

dashboard. 12 of the 18 scanners

healthy. Six are erroring out right now.

And then we can see each of the

scanners. This is great. I can see the

last run, the next run, how long they've

been running for. This is really, really

cool. I wonder what happens. Can I click

it and something happens? Okay, I click

it. It's loading. I'm going to imagine

it's going to show me the runs and what

it discovered and things like that. Oh,

wow, boom. I can see it. The last run,

the run history, everything in it. I

love it. That's really, really sick. So,

it did a really good job, and it looks

very nice. Now that we have the code

built, let's go back to our open claw

because again, we want to use the

smarter model as the checker, make sure

things went well, almost like a Ralph

loop. And let's say, "Check out the code

here and let me know what you think."

And I'm going to hit enter. Now, Henry

will go and check out all the work on

Hermes. If there's improvements needed

to be made, open claw will let me know.

This is how you both get better

performance and also save tons of money

because your more expensive agents

aren't doing the work. All right, and

here's the view. This is solid work,

builds clean and well-structured. Here's

my take. Looks like it's pretty good.

Has some notes for improvement, and we

can give that back to Hermes now to fix

that. But now you can see the system in

action, and it's so good. Use case

number two is the monitor system. I

regularly schedule cron jobs with Hermes

to check on things that Henry is doing.

The reason why I can do this is because

Hermes is cheaper to run because I'm

using cheaper models and it's a

lightweight agent. I can have it

constantly monitoring things Henry has

built out. So, for instance, those

scanners that Henry originally built, I

have Hermes go in and every 2 hours just

look into them. So, kind of like this

dashboard system we just built out, I

had it running on cron jobs before this

in Hermes, and it would go, see the

state of all the scanners, give me

advice on what's working and what isn't,

and just had this do it every 2 hours

and alert me when things were wrong.

Because Hermes is lightweight and

cheaper, you can have it doing cron jobs

a lot more often, checking in on other

things, checking in on what Henry is

doing, or even checking in on social

media, your emails, whatever it is.

Hermes acts as a way better monitor than

Henry because of its lightweight and

cheapness. So, if you have an app you

built with open claw, or you just have

some sort of process your open claw

does, setting Hermes up as kind of a

hallway monitor that's just checking in

every few hours to make sure it's going

well, and alerting you if something goes

wrong is a really powerful way to be

using Hermes just because as an

assistant it's just really good at these

types of tasks. Again, it's all about

checks and balances, them checking each

other's work, making sure it's going

well. It's just increasing the

reliability and performance of

everything your agents are doing. The

third use case I want to go over is a

shared memory workspace. What does that

mean? That basically means you have a

custom memory system that both agents

use where they can share information

with each other. This dramatically

improves the memory of your agents

because now everything your agents do

separately goes to one centralized space

that helps improve the memory of all

your agents and just make them all

better. The more mistakes each agent

makes, the more information that goes to

the shared memory system and improves

all your agents overall. Let me show you

how this works. So in Obsidian, I have a

few different folders here you can see

over on the left-hand side. You can see

an agent Hermes folder, an agent Open

Claw folder, and an agent shared folder.

In the individual agent Open Claw and

agent Hermes folders are all their

memory. So everything they're doing,

their daily logs, the mistakes they're

making, and any working context they

have. This is great for improving each

individual agent's memory. But here's

where it gets good is the agent shared

folder. Now they have a shared workspace

that they're both checking in on to see

what each other are doing, lessons

they've learned, decisions they've made,

and it helps them improve each other.

This is where like the recursive

self-improvement comes in is when one

agent learns something or makes a

mistake or gets better, it's able to

share all that information with the

other agents as well. By having two or

more agents doing work, they're now

improving each other even faster. As you

can see, I was planning this YouTube

video this morning with my Hermes agent

and it put the entire plan for this

YouTube video inside the shared folders

so that I can then go to my OpenClaw and

say, "Hey, what do you think about this?

How would we improve this YouTube

script?" And things like that.

Everything is stored in the shared space

so that they can improve each other.

This is a much better memory system than

having just a bunch of separate agents

working and not talking to each other.

This is all done in Obsidian, which is a

completely free app you can download. I

have a guide on Obsidian. I'll link to

that down below on using Obsidian with

AI agents. Make sure to check that out

right after this if you want guidance on

setting up the shared memory system as

well. Just as a side note, too, for all

of these, you can just copy and paste

this YouTube video or hit share down

below and then copy link and then give

it to your agents and say, "Hey, check

out this YouTube video and set all this

stuff up." It'll actually generate a

transcript for you, look through the

transcript, pull out all the learnings,

and set this up for you. So, super easy

to implement anything I share with you

in any of these videos. Just take the

link to the video and give it to your

OpenClaw or Hermes and it will set it up

for you. So, we talked about the planner

builder system. We talked about the kind

of hallway monitor system where Hermes

is checking in on OpenClaw, making sure

things are running well. We talked about

the backup system where if you upgrade

and one thing breaks, they can get each

other's backs. We talked about the

shared memory system. These are core

infrastructure use cases where if you

implement these, everything just gets

better and improves. Your memory stops

going to crap, your performance gets

better, you save money, things break

less, everything just improves. So,

implement these core structures into

your multi-agent system and things will

be great. I'll put links down below for

both OpenClaw and Hermes agents so you

can get them installed and use them

together. Leave a like, subscribe, and

turn notifications if you got anything

out of this. And again, I do live

bootcamps every week on Hermes and

OpenClaw. That is in the Vibe Coding

Academy. Link for that down below. Make

sure to join that now if you want to

learn a ton more about AI and the most

important cutting-edge skills on planet

Earth. I hope this was helpful and I'll

see you in the next video.