The argument in one line.
A self-improving AI agent that records its own decisions and packages them into reusable skills can replace the repetitive front-end of an agency — outreach, meeting analysis, and follow-up — without a team.
Read if. Skip if.
- You run a service business or agency with 1–10 clients and want to stop manually writing cold emails and follow-ups.
- You're already using AI tools (OpenClaw, Claude, ChatGPT) but want something that persists memory and learns your specific workflows.
- You have Fathom or Fireflies call recordings and want them automatically summarized, tagged for hot leads, and actioned.
- You're comfortable in a terminal and want to build a custom dashboard rather than pay for another SaaS seat.
- You have zero clients or no existing sales calls — the meeting intelligence engine needs real call data to train on.
- You want a no-code solution — this build uses Claude Code, pnpm, Supabase edge functions, and terminal commands throughout.
- You're looking for a polished product to buy rather than a system to build and maintain yourself.
The full version, fast.
Hermes is an open-source AI agent built by NousResearch that writes its own SOPs as 'skills' after completing complex tasks, compounding its usefulness over time instead of resetting on every session. This video is a full walkthrough of building a three-component agency stack on top of it: a meeting intelligence engine that ingests Fathom calls and flags hot leads, a self-improving SDR that learns which outreach messages close, and a React/Supabase mission control dashboard. The build uses Claude Code as the programmer agent while Hermes operates the system post-handoff, creating a clean orchestrator-builder-executor separation that reduces both cost and cognitive overhead.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Cold Open — Stripe + Promise
Revenue screenshot hook, introduces Hermes as the agent behind the results, promises a full from-scratch build.

02 · What Is Hermes
Explains Hermes vs OpenClaw, the trajectory-to-skill loop, and NousResearch's self-improvement thesis.

03 · Cost and Model Options
Free model options (OpenRouter, local), Anthropic API costs, and why $0–20/month is realistic for starting out.

04 · Three Levels of Hermes
Level 0 (terminal/Telegram), Level 1 (Hermes Workspace dashboard), Level 2 (custom mission control) — most tutorials stop at Level 0.

05 · Install — Level Zero
One-command install, API key configuration, Telegram bot setup, and testing the base Hermes install.

06 · Hermes Workspace — Level One
Full walkthrough of the open-source dashboard: chat, files, terminal, cron jobs, memory files, skills browser. Includes troubleshooting the pnpm/gateway setup.

07 · Knowledge Fortress — Five Layers of Context
Documentation, security, technical, strategy, and historical research layers — how to build deep project context for any AI agent.

08 · Agent Taxonomy — Orchestrator, Builder, Executor
How to separate agent roles by capability tier to maximize efficiency and control cost at scale.

09 · OpenClaw vs Hermes — The Honest Comparison
No clickbait: they solve different problems. OpenClaw as Swiss Army knife, Hermes as memory/skill specialist. Migration guide overview.

10 · The Build Begins — Mission Control Architecture
System design for the custom dashboard: what components are needed, how Hermes and Claude Code will divide the work.

11 · Design and Theming — Screenshot-Driven UI
Using a screenshot of the existing Agents in a Box app to drive Claude Code's design decisions. Building the React/Supabase scaffold.

12 · Webhook Automation — Automatic Meeting Sync
Fathom webhook integration that pushes new call recordings into Supabase automatically, triggering the meeting intelligence pipeline.

13 · AI-First Architecture — Every Feature Must Be API-Accessible
Design principle: all dashboard features must be callable by agents, not just humans. Building the integration guide and endpoint registry.

14 · Hermes Takes Over — Builder Hands Off to Operator
The moment Claude Code finishes scaffolding and Hermes begins operating the system via natural language. The handoff pattern explained.

15 · Meeting Intelligence — Sales Call Review and Patterns
Auto-analysis of Fathom calls: key takeaways, next steps, hot lead scoring, and linking meeting data to outreach campaigns.

16 · Cron Jobs — Meeting Analyzer, Hot Leads, Daily Briefing
Building scheduled tasks entirely via natural language: nightly meeting processing, hot lead alerts, and a morning Telegram digest.

17 · Self-Improving SDR — Outreach Engine That Learns
The agent analyzes reply rates, updates its own messaging patterns, and runs the next campaign with refined copy — no manual A/B testing.

18 · Email System — Resend Integration
Wiring Resend for transactional and sequence emails: domain verification, API integration, and tracking opens and clicks in the dashboard.

19 · Nurture Sequences — Make Them Show Up to the Call
Automated pre-call sequence with no-show detection: webhook from Cal.com triggers a multi-touch Resend sequence to cut no-show rates.

20 · Campaign Builder — CSV Upload and AI Personalization
Apify scrapes leads, CSV uploads into the dashboard, Hermes personalizes each message using meeting intelligence context.

21 · Wrap-Up — System Review and Next Steps
Full system recap, what was built vs. planned, Agents in a Box community pitch, and preview of the Cloud Code Masterclass.
Lines worth screenshotting.
- Every agent resets when the session ends — except Hermes, which writes a 'trajectory' after each complex task and converts it into a reusable skill file.
- Hermes learns from 1,713 sales calls to build a personal selling model that mirrors how you handle objections — not a generic script.
- $54,613 in 30 days from six clients without writing a single cold email is the claimed outcome of running this stack for one quarter.
- The three-level Hermes stack: terminal only (level 0), open-source web dashboard (level 1), custom mission control (level 2) — most tutorials stop at level 0.
- Skill files Hermes writes for itself include pitfalls, lessons learned, and verification steps — more like an internal wiki than a script.
- The Orchestrator-Builder-Executor taxonomy separates OpenClaw (orchestrator), Claude Code / Codex (builder), and Hermes (executor) — each handles a different cost and complexity tier.
- Claude Code builds the app while Hermes runs it: the handoff moment is when the builder agent finishes scaffolding and the operator agent takes over with natural language commands.
- Hot lead detection in the meeting intelligence engine flags discovery calls where the prospect matched the solution pattern — no manual tagging required.
- Cron jobs on Hermes need no code: one sentence like 'every morning at 9am, pull my Fathom meetings and send a Telegram digest' generates the full scheduled task.
- Memory in Hermes lives in two files: memory.md (agent's notes on tools and workarounds) and user.md (your profile and preferences) — both loaded into every session automatically.
- The Knowledge Fortress is five layers stacked into a Claude Project: documentation, security, technical, strategy, and historical research — context depth determines output quality.
- Hermes' 65,000 GitHub stars grew by 35,000 during the four hours of filming — it became the fastest-growing AI agent on GitHub in that window.
- OpenClaw and Hermes solve different problems: OpenClaw is a Swiss Army knife with 50+ integrations; Hermes is a specialist with self-improving memory and skill creation.
- A nurture sequence built with Resend and Hermes can detect no-shows and automatically re-book them — triggered by webhook, no human in the loop.
- AI-first architecture means every feature must be API-accessible from the start, so agents can take actions without a human opening a browser.
How to build an agency brain that never resets
The gap between an AI assistant and an AI operating system is persistent memory and self-written SOPs — and closing that gap is a system design decision, not a tool purchase.
- Revenue numbers in the hook are earned credibility, not decoration — the specific Stripe screenshot ($54,613, 12 payouts, 6 clients) sets a falsifiable standard the rest of the video has to meet.
- Hermes creates 'skill files' from its own completed tasks — standardized SOPs it wrote for itself that load automatically next time, compounding rather than repeating.
- The trajectory-to-skill loop is the mechanism: after any task requiring five or more tool calls, Hermes logs every decision, evaluates reusability, and writes the skill file with pitfalls and verification steps.
- Three-level deployment matters: most tutorials show Level 0 (terminal only), but Level 1 (dashboard) and Level 2 (custom app) are where the meeting intelligence and outreach automation actually live.
- The Knowledge Fortress pattern (five context layers stored in a project) is what separates an agent that gives generic answers from one that knows your specific stack, clients, and preferences.
- Level 1 context (name, role, communication style, current projects) is the minimum useful threshold — Level 2 and 3 are enterprise-depth and take 10+ hours to build properly.
- Separating orchestrator, builder, and executor roles prevents cost blowouts — use the cheapest capable agent at each tier, not your best model for every operation.
- Giving Claude Code a screenshot of an existing app you like is faster and more reliable than writing a design spec — the model reverse-engineers the visual language and applies it.
- An AI-first architecture principle — every feature must be API-callable, not just human-clickable — is a design decision that must be made at the start, not retrofitted after launch.
- The Claude Code / Hermes handoff is the key workflow: Claude Code builds and scaffolds, then Hermes operates the finished system — don't try to use one tool for both phases.
- Hot lead detection in meeting intelligence works by pattern-matching discovery call transcripts against historical closed deals — the agent builds the pattern from your own call history, not generic templates.
- Cron jobs built with a single plain-English sentence (no code) are Hermes' most underutilized feature — meeting analysis, lead alerts, and morning briefings all run this way.
- A self-improving SDR learns which message patterns correlated with booked calls, updates its own templates, and applies the improved version to the next batch — feedback loop without a human in the loop.
- Nurture sequences triggered by Cal.com webhooks cut no-show rates by automatically re-engaging booked leads before the call — the same webhook that books the call starts the sequence.
Terms worth knowing.
- Trajectory
- Hermes' internal log of every API call, decision, and tool use in a completed task. After finishing, Hermes reviews the trajectory and decides whether to convert it into a reusable skill.
- Skill (Hermes)
- A self-written SOP that Hermes creates from a trajectory. Stored as a markdown file, it includes step-by-step instructions, pitfalls, and verification steps — loaded automatically when similar tasks arise.
- Knowledge Fortress
- A five-layer context architecture (documentation, security, technical, strategy, historical) stored in a Claude Project to give AI agents deep, project-specific context on every session.
- Orchestrator Agent
- The manager layer of an agent stack (e.g., OpenClaw) that coordinates tasks, delegates to specialist agents, and handles edge cases — does not write code or execute tasks directly.
- Builder Agent
- The developer layer (e.g., Claude Code, Codex) that writes code, constructs systems, and wires integrations — hands off to an executor once scaffolding is complete.
- Executor Agent
- A specialist worker (e.g., Hermes, OpenClaw sub-agents) that completes specific tasks — runs skills, processes meeting data, sends emails — under direction from the orchestrator.
- Self-Improving SDR
- An outreach agent that analyzes which messages generated replies and meetings, updates its own prompting patterns, and applies the improved approach to the next batch — no manual A/B testing.
- Meeting Intelligence Engine
- The component that ingests call recordings from Fathom or Fireflies, auto-generates summaries and action items, detects hot leads, and stores structured data in Supabase for Hermes to act on.
- Fathom
- A meeting recorder and AI notetaker that captures calls, generates transcripts and summaries, and exposes them via webhook for downstream automation.
- Mission Control Dashboard
- The custom React/Supabase web app built in this video — a single-screen view of meetings, outreach status, campaign performance, and agent activity for an agency operator.
- NousResearch
- The AI research lab that trains the Hermes model family and built the Hermes agent — their core thesis is that an AI agent should get measurably better each time it's used.
- Apify
- A web scraping and automation platform used here to build the lead sourcing layer of the outreach campaign — scrapes prospects into a CSV for the SDR to personalize.
Things they pointed at.
Lines you could clip.
“I didn't write a single cold email. I didn't review a single discovery call. I didn't even draft the proposals. An AI agent did it.”
“An AI agent should get better the more you use it. Every other agent out there resets — Hermes doesn't work that way.”
“They are not the same two. They don't even compete in the same category in my opinion.”
“What you have now is a single brain that sees everything. Most agencies have scattered tools — CRM here, emails there, meeting notes somewhere else, founder's brain holding it all together.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
Fifty-four thousand dollars in thirty days, twelve payouts, six clients — and not one cold email written by hand. That's the opening claim, and the next four hours are the receipts: a complete rebuild of the AI agent system that runs the front end of his agency, from lead sourcing to meeting intelligence to self-improving outreach, all orchestrated by an open-source agent that gets smarter every time it completes a task.
Named ideas worth stealing.
Orchestrator-Builder-Executor Taxonomy
- Orchestrator (OpenClaw) — coordinates, delegates, handles edge cases
- Builder (Claude Code / Codex) — writes code, constructs systems
- Executor (Hermes, sub-agents) — runs skills, processes data, takes actions
Three-tier agent role separation that controls cost and prevents capability mismatch — use the right agent type for each layer.
Knowledge Fortress — Five Layers of Context
- Documentation layer (PRDs, schemas, UI/UX)
- Security layer (best practices per platform)
- Technical layer (prompting, stack selection)
- Strategy layer (personal preferences, project direction)
- Knowledge layer (research, historical interactions)
Five-layer context architecture stored in a Claude Project that gives any AI agent deep, project-specific knowledge on every session.
Three Levels of Hermes
- Level 0 — terminal and Telegram (most tutorials stop here)
- Level 1 — Hermes Workspace open-source dashboard
- Level 2 — custom mission control web app
Progressive capability tiers for Hermes deployment — each level adds visibility and control over what the agent is doing.
Trajectory-to-Skill Loop
After each complex task, Hermes logs every decision and API call into a trajectory, then evaluates whether it can be packaged into a reusable skill file — the core self-improvement mechanism.
AI-First Architecture Principle
Every feature in a human-facing dashboard must also be callable via API so AI agents can take the same actions without opening a browser — baked in from design, not retrofitted.
How they asked for the click.
“If you want to skip the entire thing, get all of this and also the application that I was showing you — Agents in a Box. First link in the description.”
Delivered at end after showing a more powerful version of what was built; creates aspiration gap. Complemented by a free Gumroad playbook (second link) for those not ready to pay.



























































