Harnessing Hermes and Grok Bot: The Autonomous Agent

Tool vs teammate

Everything you've built in this course so far has one thing in common: you start it. You open the chat. You give the coding agent its task. You review the output. Even the best Module 5 automation sits still until you show up and press go.

Everything so far, you start. An autonomous agent starts on its own.

That's the whole jump from Level 4 to Level 5, and it's bigger than it sounds. An autonomous agent checks the bank statement when it arrives. It drafts the reminder when rent is late. It watches the inbox and flags the two emails that actually need you, without being asked, because nobody was there to ask it.

This needs a different mental model. A hammer is a tool: it does nothing until you pick it up. A colleague is different. You don't operate a colleague. You onboard them, agree on what they handle, check their work as often as your trust requires, and hand over more with time. That's exactly how you'll work with Hermes or Grok Bot.

ReAct in action

Before you can manage an agent, you need to know how it thinks. It runs a loop, Reason → Act → Observe, called ReAct. Every agent you'll use works this way: the coding agents from Module 5, Hermes, and Grok Bot.

• Reason. The agent looks at its goal and its situation and picks the next step. For example: "Rent for unit 12 was due yesterday, and nothing matching it is on the bank statement."
• Act. It does one concrete thing: reads a file, calls a tool, drafts a message. "Draft the reminder SMS and queue it for approval."
• Observe. It looks at what happened and feeds it into the next round. "Approved and sent. Log it, check again tomorrow."

Then it loops. That's also why agents recover from surprises: a failed action is just another observation, and the next Reason step works around it. A chatbot answers and stops. An agent keeps looping until the goal is met or it needs you.

Remember Module 1: underneath, this is still a next-word prediction machine. The loop is what turns prediction into work, because every cycle grounds the model in what actually happened instead of what it guesses happened.

A chatbot answers and stops. An agent loops until the job is done, or until it needs you.

Two ways to run an autonomous agent

The architecture in plain English: the autonomous agent sits above the tools from Module 5 and decides when they should run. It doesn't replace what you've built. It's the layer that starts the work. You can run that layer two ways.

This is why the course was ordered the way it was. If we'd started here, either one would be a black box. Because you've directed a coding agent yourself, you know what each layer is doing when the agent runs it. You read its work the way a manager reads a report from a team they used to work in.

Connecting your world

An agent is only as useful as the world it can reach. With no connections, it's a very smart colleague locked in an empty room, reasoning about work it can't see or touch.

So the first real build step is wiring the agent into the software your work lives in:

• The channel it reaches you on. Hermes connects to many messaging apps; I mostly use Telegram. The app itself for Grok Bot. This is where reminders, questions and "approve this?" arrive.
• Your work accounts. Email, calendar, drive, spreadsheets: reading the inbox, checking your schedule, filing documents.
• Your daily tools. Whatever your workflow runs on. This part is personal, which is why we do it on your real accounts, not a sandbox.

The mechanism is one you already know: MCPs, the connectors from Modules 3 and 5. In Grok Bot they're called connectors, and they're MCP underneath. The difference from Module 5 is duration. Until now a connection lived inside a session. For an autonomous agent it's permanent and always on. The wiring is part of the agent, not the conversation.

Giving your agent an identity

In Module 5 you wrote a CLAUDE.md: a role and instructions for a coding agent that wakes up fresh each session. An autonomous agent needs more, because it doesn't wake up fresh. It persists. Identity is what makes a hundred separate conversations feel like one colleague. It has three parts.

1. Personality & voice

How it communicates: short or thorough, formal or direct, when to ask and when to decide. This isn't cosmetic. You'll read this agent's messages every day, and a voice that matches how you work is the difference between a teammate and a notification you learn to ignore.

2. Who you are & your business

Your role, your company, your priorities, the people you deal with, how your numbers work. You are the domain expert, and nobody can write this for you. In Grok Bot, each teammate gets its own: my Rentals agent is being set up with Байр 3's units and payment habits, and my Education agent knows my brand, my voice and my course outlines.

3. What it remembers between conversations

Decisions made, preferences learned, the state of ongoing work. Tell it once that I want @everyone on every Discord announcement, and it's still true next month. In Hermes you keep this in memory files. In Grok Bot, memory is built in: it keeps what matters between conversations. Either way, this is Pillar 1 in Section 8.

You don't configure an autonomous agent. You onboard it, the way you'd onboard a sharp new hire.

Skills & automations

Now the proactive part, where work happens without a prompt. The building blocks are the same in both. Only the names change.

The distinction worth remembering: a schedule is a decision you made; a heartbeat is judgment on a schedule. Scheduled work covers what you already know repeats. A heartbeat or event trigger catches what you couldn't schedule: the unexpected email, the payment that didn't arrive, the meeting that moved.

At Байр 3 the daily rent check is the obvious one: the bank statement comes in, payments get matched to units, the sheet gets updated, and tenants who haven't paid get a message. That's a skill. Today it runs on Hermes. Section 7 shows how it climbed the ladder. And notice what a skill really is: the SOP you mapped in Module 4, one translation away. If you did that exercise on a real workflow, your first skill is half-written.

If you want to see how others wrote theirs, members of the AI Architects community share skills and setups there.

The Trust Ladder

The question you're probably asking by now: "You want me to give software standing access to my email, and let it act on its own?" Good. That instinct is right, and the Trust Ladder is the disciplined answer. Autonomy isn't a switch. It's a dial with four positions.

In Hermes you build the ladder yourself, in its instructions and in which actions you let it take. Grok Bot ships with rung 2 as the default: it drafts, then asks for your approval before sending or posting anything. Risky actions need your approval first. That's why all four of my teammates sit at rung 2 for anything public: Marketing drafts the posts, Education drafts the Discord announcement, and nothing goes out until I tap yes.

This is the human-in-the-loop rule from Module 1, made concrete. Back then I said the real skill is deciding where you sit in the loop. The Trust Ladder is that decision, per task, with names on the rungs.

How my rent workflow climbed

Before: rung 2, Draft & Approve.

• I sent the bank statement.
• The agent asked where to apply each income and expense. I approved.
• It wrote the sheet.
• It produced the rental report, the tenants who haven't paid, with a drafted message for each. I approved.
• It sent them.

Now: rung 3, Act Within Bounds.

• I send the bank statement.
• It applies the matches it's confident about and asks me only about the unclear ones.
• It produces the rental report, picks the right message template for each tenant, and sends them on its own. No approval.

Nothing about the model changed. What changed is the track record: I've run this workflow and this skill many times, watched it get them right, and fixed it when it didn't. That's what earned the promotion. And it was earned for this one task, not for the agent as a whole.

This runs on Hermes today. My Rentals agent on Grok Bot is set up to take it over, and it will start where every new hire starts: back on rung 2, earning its way up.

Autonomy is earned, not granted, the same way you'd delegate to a new employee.

The 3 Pillars

Everything in this module comes down to one operating model. A well-run agent stands on three pillars, and every problem you'll have with one traces back to a pillar being neglected.

Notice how the course folds into this. Pillar 1 is what you wrote in Section 5, plus the handbooks, skills and data you leave in its folder. Pillar 2 is Module 1's context window, now managed for someone else. Pillar 3 is Module 1's human-in-the-loop rule, turned into a dial. The capstone isn't new material. It's all the old material, finally standing up together.

The habit: when the agent underperforms, ask which pillar failed. Wrong facts about your business? Knowledge: fix the memory, or the file it read. Losing the thread mid-task? Context. Doing things it shouldn't, or asking for things it should own? Autonomy. Three pillars, three fixes. That's what managing an agent means day to day.

The live capstone

The module ends the only way a build module can: your agent handles one real daily workflow, end to end, in front of you. One of yours, picked with the Module 4 value screen: does it reduce cost, increase speed, or improve quality?

One common shape of it, on the day:

• 07:30: a cron job, heartbeat or routine fires. The agent scans the inbox and calendar. Nobody prompted it.
• 07:31: it finds three items needing action and drafts replies, following your skill.
• 07:32: your phone buzzes with the three drafts and one question: "Approve?" A message from Hermes (Telegram, in my case), or an approval card in Grok Bot, because this task sits at rung 2.
• 07:34: you approve two and edit one. Sent, filed, memory updated.

Four minutes, most of them the agent's. That's Level 5 on a real workflow, and every piece of it is something you built during this course.

The capstone build, step by step

This is the exercise we run in session. Like all of Modules 4–6, it's done on your real workflows. The steps are fixed; the content is yours.

1. Pick one real daily workflow. Run it through the Module 4 value screen. Small and daily beats impressive and occasional: the daily one builds a track record faster.
2. Write the SOP down. Trigger, steps, sources, output, and what "done" looks like. If you can't write it, the agent can't run it.
3. Pick your runtime and connect only what the workflow needs. Install Hermes and connect the messaging app you live in, or set up Grok Bot and add the connectors. Don't connect everything on day one.
4. Write the identity. Voice, who you are, your business, and the first things it should remember. Expect to revise it weekly at first. That's normal onboarding.
5. Turn the SOP into a skill, then schedule it. A cron job or scheduled routine if it runs at a known time. A heartbeat or event-triggered routine if the agent should watch and judge.
6. Start at rung 2, Draft & Approve. The agent does the work, you hold the send button. Write down what evidence would justify rung 3.
7. Run it live and review like a manager. Watch one full cycle. Fix the identity, tighten the skill, note what you'd change. The capstone is done when the workflow happens without you starting it.

The people who do the work should be the ones who design the AI that supports it. As of today, that's you.