Sash drives this one, screen-sharing the always-on AI agent he runs in the cloud and showing how Claude Code became the tool that keeps it alive. His agent (Blaze) runs on a standard OpenClaw image inside a Hostinger Linux VPS, controlled over Telegram, and reachable only across a private Tailscale network so no one outside his own devices can touch it. The kicker: Sash had never used Linux. He never SSH'd into the box by hand or hand-edited a config. He asked Claude Code to connect over Tailscale, generate an SSH key, install OpenClaw, and wire it up. Chris runs the same pattern with a Hermes agent on a Mac, and the two setups landed on the identical stack independently - Hostinger, Telegram, Tailscale - which becomes the episode's running joke and its real point: this is just enterprise security and operations practice applied to personal AI agents.

The heart of the demo is a live debugging session. Sash had been hitting transient failures where Blaze would go quiet mid-task and silently drop work with no feedback. He pointed Claude Code at the VPS and asked it to verify Blaze's health and hunt for transient errors over the last seven days. Claude Code read the logs and found the real cause: after Sash migrated Blaze off the Anthropic API (which was costing ~$25/day) onto an OpenAI Codex subscription over OAuth, a config parameter - missing assistant retries, defaulted to zero - meant the agent never retried after a stop. It also surfaced a second, invisible failure: Codex OAuth does not expose an embeddings model, so OpenClaw's memory-indexing system had been completely broken for three days and Sash would never have known without asking. The fix is a cheap OpenAI API key just for embeddings. Sash's plan: turn this health check into a weekly skill so Claude Code self-audits the agent on a schedule.

The takeaway both hosts keep circling is the orchestrator/watchdog pattern - a primary agent (Claude Code) supervising other autonomous agents, the same way you'd never ask a single SQL table to monitor the health of its own database. That framing sets up the show's next arc: starting next week, a multi-episode "AI for Enterprise" series, opening with Responsible AI (Microsoft's RAI framework, NIST), then token spend and building institutional knowledge through shared skills.

Key takeaways:

• Don't run an always-on agent on your laptop. Put it on a cheap VPS (Hostinger, DigitalOcean), lock it behind a Tailscale private network, and reach it over SSH so no passwords sit in env files and nothing outside your own devices can connect.
• You don't need to know Linux. Ask Claude Code to connect to the VPS, generate the SSH key, install OpenClaw/Hermes, and configure Telegram - it does the parts you don't know how to do.
• Running OpenClaw/Hermes on an OpenAI Codex subscription over OAuth avoids per-call API bills (Sash's Anthropic API run was ~$25/day), but watch two gotchas: set missing assistant retries above zero, and add a cheap OpenAI API key for embeddings since Codex OAuth doesn't expose the embeddings model your agent's memory needs.
• Build a watchdog. Autonomous agents fail silently outside their own scope (dropped Telegram channel, missing API key, broken memory index); have Claude Code read the logs, diagnose, and turn that health check into a weekly skill.
• The orchestrator pattern - one supervising agent managing others - is just enterprise monitoring practice applied to AI. The health of a system is managed from outside the system.

Watch the video version on YouTube · Full show notes, transcript + takeaways

We called an audible. Fable 5 - Anthropic's first Mythos-class model the public can actually touch - dropped this week, so the planned episode went out the window. Sash drove. Instead of a launch-day reaction, he showed two days of real work: he handed Fable 5 a job he'd been deferring for weeks, a full 31-lesson curriculum review spread across roughly 40 markdown files, with instructions to reformat lesson timing, reconcile contradictions between lessons, and update the Claude Code configuration by researching current Anthropic docs. Opus 4.1 had choked on the same task earlier with context issues. Sash resumed the exact same Claude Code session, flipped the model from Opus to Fable, and let it run.

What stood out was the autonomy. Unprompted, Fable created its own work-log file, spun up a review folder for its notes, confirmed the scope (31 lesson files, 5 project files), then asked a batch of strategic yes/no questions before doing anything. It ran ~26 minutes unattended, fired up six subagents to research and write in parallel, and stopped to ask follow-up questions only when it hit a real decision it shouldn't guess on - like which of two contradicting lessons to keep. Total execution was 29 minutes for work that took Sash two days to review, and he didn't have to change anything.

The receipts: 665,000 output tokens (about 80% of Sash's daily 5x Max allowance), 137 file operations, 21 messages back to him, and only three tool errors across the whole run. The pricing catch matters: Fable is roughly 2x the cost of Opus 4.8, bundled into Pro/Max subscriptions only until June 22, after which it moves to usage credits (you pay API cost on top of your subscription). Chris pushed the honest question throughout - when does this actually pay off versus when is Opus still the right call?

Key takeaways:

• Use Fable 5 for long, complex, bounded jobs where you can describe the outcome and walk away - not for trivial chores like organizing a downloads folder. You will just burn tokens.
• Plan first. Start with the outcome, have Fable reverse-engineer the plan, approve it, then let it execute. It is noticeably better than Opus at building a plan from a stated end state.
• Higher effort settings (x-high / max) make Fable re-check its own work more, so accuracy increases on longer-running tasks instead of degrading. This is the opposite of watching Opus drift while holding 400K tokens in one context window.
• Watch your usage. A single review pushed Sash to ~80% of his daily 5x Max limit; on a Pro plan it will eat your allowance fast. Budget Fable for your highest-value task on deck.
• Resuming an existing Claude Code session and flipping the model (Opus -> Fable) preserves context - a clean way to escalate a task the daily driver stalled on.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Chris drives EP.10, a direct sequel to last week's monitoring episode with Rene. He opens with a failure: he added a feature to his Life OS (TheGrove), it tested green, and three days later every automation had stopped. The one that stung was the 8am morning-journal prompt - the first automation he ever built and the thing the rest of the system sits on top of. The trigger was tiny: a change that moved a single file. Claude ran 671 unit tests, every one came back green, because the tests checked the code, not whether the real automations still fired. The failure was silent - no alert, he only noticed because the morning messages stopped arriving.

The fix is a regression layer. Every time something breaks, Claude logs it to a regressions.md file inside TheGrove, and those entries get collected into a /smoke skill - smoke testing as a running ledger of everything that has ever broken, plus the key automations that must keep working. /smoke now runs as a subskill inside Chris's SDLC (called by his plan and goal workflows after unit tests, QA, and red-team pass), spinning parallel sub-agents to re-validate all 16 predicates. It has caught real breaks, and Chris's trust in the system has gone up as a result.

The conversation widens with Sash into self-healing systems. Sash draws the analogy to Microsoft Exchange, which reached self-healing by roughly 2015 on plain deterministic code; AI needs the same safety net but is non-deterministic, so you should assume it will fail and build the catch-fix-document loop around it. They land on a reframe: the AI model is tech, but the agent belongs under people - you manage it like a capable teammate who still makes mistakes. Chris's north star is self-fixing: don't just tell me it broke, tell me you already fixed it. The episode closes teeing up EP.11 - Sash using Claude Code to manage and secure OpenClaw, agents managing agents.

Key takeaways:

• Passing unit tests can still hide a broken system. 671 green tests checked the code, not whether the real automations fired - test the outcomes you actually depend on, not just the units.
• Turn every incident into a permanent check. Log each break to a regressions.md and collect them into one smoke-test skill so the same failure can never silently return.
• Run smoke testing as part of your SDLC, not ad hoc. Call it after unit, QA, and red-team pass, before anything gets marked done.
• Assume non-deterministic systems will fail and build the detect-fix-document loop around them. Aim for self-fixing, not just alerting.
• Treat autonomous agents as people, not tech. More autonomy means a larger failure surface, so manage them with process and watchdogs.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Rene Charbonneau walked through his evolution from LibreChat to OpenClaw to Claude Code - and the $200/day Opus invoice that turned into a "welcome to AI" tuition payment. The trigger that pulled him in was building a household chat so his family could share AI context without forwarding screenshots. Once a non-developer saw his own commits land in a Git repo and ship across environments, he stopped treating AI as a tool and started treating it as a workflow problem.

The core of the episode was a four-phase refactor loop he iterates on weekly: foundation (slash commands first, plus a secrets hook that pipes credentials from BitWarden straight into the environment so API keys never enter the chat log), measure (a TDD audit caught his pipeline running at 17% coverage versus the 80% he had specified), tune (PreToolUse/PostToolUse hooks enforce gates before commits land), sustain (a cron job ships three retro items a day at low blast radius). The piece a solo builder usually loses is the people leg of people/process/technology - Rene gets it back with a five-agent Opus council (CISO, CPO, CTO, co-founder + a synthesizer that prunes to what's critical now) that reviews every spec before the build agents touch it.

Chris and Rene compared their independently-built SDLC pipelines and found near-identical phase shapes - scope, plan/design, implement, review, ship, retro - differing mostly in review style (Chris programmatic, Rene LLM-driven). Hot take from the guest: AI won't gut middle management, it will turn middle managers into "Bill Russells" - player-coaches who can finally build the system they used to delegate. Sash extended the analogy to shadow IT - if you don't give your high-agency people a Claude subscription and permission to experiment, they'll build it anyway, just somewhere you can't see. Chris closed by teasing EP.010 on watchdog and regression systems, and Rene left the audience with the one rule he's anchored on: validate every agent output against tangible artifacts (database rows, files), never against the agent's own text summary.

Key takeaways:

• Keep secrets out of chat logs - pipe credentials through a hook that injects from a vault into the environment, never into the prompt.
• Audit TDD and coverage with a separate agent. Your build agent will overstate what it actually shipped; a spec audit catches it cheap.
• Build a multi-role Opus council (CISO, CPO, CTO, co-founder, synthesizer) that reviews specs before build. Solo builders need the people leg, not just process and tech.
• Trickle retrospective items through a daily cron - three at a time. Lower risk than batching them into a refactor sprint.
• Validate AI output against hard artifacts (DB rows, files), never against the agent's own text summary.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Sash drives this week, walking Chris through MCP (Model Context Protocol) - the standard Anthropic released in November 2024 that lets LLMs talk to external apps, data, and tools. Chris frames it as "the API for agents" and Sash confirms it: a shared language that agents speak to reach Gmail, Granola, n8n, anything with a server. They tour the Claude connector marketplace (Gmail, Calendar, G Drive, Granola), inspect a connector's tool list, and show the per-tool approval model that controls what an agent is allowed to do without a prompt.

The conversation gets practical fast. Sash uses a third-party Google MCP for his Hermes agent because the community version does more than the official one, and a 21k-star n8n MCP that lets Claude build workflows without him touching n8n. He also surfaces the stability tradeoff - one of his custom MCPs is currently failing in /mcp - and the hidden cost that bit Chris: every connected MCP auto-loads its tool definitions into context, so stacking dozens of them can quietly burn your context window. That nudged Chris back toward straight APIs (like Exa for semantic search) for things he can scope tightly himself.

They land on a heuristic: if a marketplace MCP exists and is stable, use it; if not, fall back to a scoped API. Chris floats the idea of an "OpenRouter for MCPs" - a proxy that routes between MCPs to keep context lean - and they note auth would be the hard part. Next week brings the show's first guest: Rene Charbonneau, on why your AI systems drift and how to keep evaluating them.

Key takeaways:

• Treat MCP as the API surface for agents - if a vendor or community MCP exists, try it before writing custom API plumbing.
• Audit your MCP list. Every connected MCP auto-loads its tool definitions into context. Stacking n8n, Make, and a dozen connectors will silently eat your context window before your prompt even runs.
• Use the per-tool approval gate in connectors. Mark read-only tools 'always allow' and keep write/delete on 'needs approval' so agents can move without you babysitting safe calls.
• Look at community MCP repos before defaulting to official ones - Sash's Hermes uses a 3rd-party Google MCP that beats the official one, and the n8n community MCP has 21k stars.
• When you need tight scope control or token discipline, drop to an API. Exa for semantic search and Duffel for travel booking are good examples - though Duffel now ships an MCP too, so the line keeps moving.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Chris breaks from the usual Claude-centric format and walks through Hermes, an always-on autonomous agent runtime from Nous Research. The framing: Hermes is the body of his personal AI stack - lightweight, learning, always listening, primarily reached over iMessage via BlueBubbles. Claude Code is the brain - heavy systems work, infrastructure, long sessions in front of a terminal or VS Code. Each Hermes profile starts with a SOUL.md that defines voice, posture, and behavior, then layers on skills (reusable patterns Hermes can create on its own after the third repetition) and a built-in cron system.

The interesting part is the multi-profile setup. One Apple ID, one BlueBubbles install, five distinct agents - Silas (Chris), Ivy (his girlfriend Amanda), Grover (the shared family agent in the group chat), Atticus (the Georgia divorce-law agent neither human talks to directly), and Neo (Tier 2 developer agent). BlueBubbles webhook routing picks the right profile based on which number is sending. Cross-context sharing between agents is gated through a Postgres events table with consent levels and a health-sensitive flag.

The payoff is the real story: one night, sitting with his son playing Pokemon, Chris got an unprompted text from Silas saying "Amanda's evening journaling prompt broke and Ivy told me to talk to you." That kicked off a tour of AgentMail - the inbox-per-agent system Hermes profiles use to coordinate. Amanda's SOUL.md instructs Ivy: when something breaks, do not tell Amanda - tell Silas. Silas is Tier 1, Neo is Tier 2, Chris is Tier 3. The agents handled the failure between themselves with neither human in the loop until escalation was required. Chris closes on cost reality (Anthropic blocks the Claude Code subscription from external runtimes, so Hermes runs on Codex with GPT-5.4-mini) and a commitment to keep iterating toward the orchestrate model.

Key takeaways:

• Split your personal AI stack into a body (always-on, reachable on the surfaces you already use) and a brain (heavy session-based work). Don't try to make one tool do both.
• Each agent profile gets a SOUL.md - voice, posture, behavior. The voice is the product. Let the person it serves co-write it.
• One BlueBubbles install + one Apple ID + webhook routing can host multiple agents on iMessage. Sender number picks the profile.
• Use an inbox-per-agent service (AgentMail or equivalent) for agent-to-agent coordination instead of inventing a new protocol. Email is a doorbell.
• Define failure routes in the SOUL itself: when something breaks, escalate to peer X, then peer Y, then page the human. That tiered structure is just on-call rotation, but for agents.
• Anthropic does not let the Claude Code subscription auth from external runtimes. If you want Hermes-style always-on with Claude models, you pay API rates. Codex on GPT-5.4-mini is the cheap workaround if you have a ChatGPT Plus or Pro subscription.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Sash walks through the Orchestrator Method - his five-principle framework for delegating real work to AI without losing the plot. The principles: define the end state, plan it with AI, deconstruct and delegate, stay in the loop, and build systems for reuse. None of it is technically novel - it is the same delegation muscle that any consultant, engineer, or manager already has - but Sash names it explicitly so you can run it as a checklist when you are wiring up agents instead of reinventing the wheel each time.

The conversation moves between the meta (when to stay in the loop, when to step out) and the practical (a Sunday newsletter workflow Sash built with Nuro, a Google Ads skill he built with Claude for the laundry business he runs with his wife). Chris ties it back to his own Grove build - he started by modeling agents like a corporate org chart with a CTO and architect and found the management overhead was wasted, so he flattened it. The big shared insight is principle four: humans stay in the loop only until trust is earned. Chris's rule of thumb is 95% - if AI is right 95% of the time and he is not adding value in review, why is he still in the loop?

The episode closes with a teaser for next week: Sash is bringing in Hermes Agent, an always-on AI Chris has been running for himself, his girlfriend, and the family. He logged in a few days ago to find his agents had been talking to each other without him.

Key takeaways:

• Use plan mode in Claude Code (Shift+Tab) before you let it write anything - it cannot touch files, so a misclick is harmless and the output is sharper.
• If you do not know what good looks like for the end state, do not guess. Ask AI to draft the spec with you - 800-1,000 words, this geography, this time window - then start.
• Pick a trust threshold for taking yourself out of the review loop. Sash and Chris both use 95%. Below it, stay in. Above it, step out and let the system run.
• The third time you do something manually, turn it into a skill. Hermes Agent does this automatically; in Claude you have to remember to ask.
• The orchestrator method is fractal - apply it to a single prompt, a single skill, an agent, or a multi-agent system. Same five steps, different scope.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Chris and Sash open Claude Code live and run the two commands that ship this show. Chris kicks off /turnover against the previous week's recording at the top of the segment - on stream, while everything else is happening - and then walks through what's actually inside the orchestration. The episode is the messy version on purpose: a live demo with the artifacts visible, errors visible, and the human-in-the-loop checkpoints built in.

The two skills are /episode and /turnover. /episode scaffolds next week from a topic - title, tagline, description, LinkedIn social card, OBS overlay, episode page, CouchDB record, homepage rebuild. Mid-show Chris uses it to create EP.06 "The Orchestrator Method" with Sash, which becomes the teaser for next week. /turnover is the orchestrator skill: it calls seven sub-skills (wrap, nextup, deploy, upload, deploy, promote, debrief) sequentially, each with its own job - whisper transcription, page updates, branch deploys, YouTube upload with auto-chapters, LinkedIn draft, Telegram debrief.

The live demo trips on a real error - main and dev had diverged because EP.05 was created without turning over EP.04 first, and --ff-only refused. Chris flags it on stream: "we're getting some errors. We're getting some human resolve stuff." That's the show. The whole conversation pivots to approval gates and how trust with AI evolves over time. Sash frames the orchestrator method as defining the outcome, breaking it into tasks, telling Claude how each task should be accomplished, then putting humans in the loop at the right places. EP.06 will cover the five principles in detail.

Key takeaways:

• Build your orchestrator skill from sub-skills, not one giant prompt. Iteration is the path: start with one thing, break it apart when it misses the mark, then chain the parts.
• Approval gates are not bugs - they're trust calibration. Start with 'draft this for me', graduate to 'I took a stab, look it over', end at 'I did it, here it is.'
• 'It's just one of us.' Treat AI like a teammate that forgets things and gets overwhelmed. Don't expect perfection; build the recovery loop.
• Skills live in the same repo as the code they ship. One git pull and either host can run /turnover on their machine.
• The messy version is the version. Errors on stream are the show, not a failure of it.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Sash demos Claude Cowork - the same engine as Claude Code, but desktop-only and task-based instead of chat-based. The pitch: knowledge workers in non-technical roles get an agentic surface for the work they actually do every day. Cowork runs sandboxed on your Mac, takes a folder for context, plans the task, and executes. Chris streams in from London on an iPad to underline the point that the show ships from anywhere with tmux.

The live demo runs an "itemize receipts and fill expense sheet" workflow. Cowork picks up 15 PDF receipts, extracts them, and writes the data into the expense template. The conversation pivots to skill packaging - if everyone in your org has the same expense form, you can wrap the workflow as a skill and hand it around. That leads into a closer look at skill anatomy: the markdown spec, the scripts subfolder for Python helpers, the resources/examples that ground the skill in real reference material.

The episode closes on a 90/10 reframe of "human in the loop" - the agent does most of the work, and the human shows up for the final shaping pass. Sash points at Granola for notes, and Chris flags that he's been spending too much time inside the terminal when Cowork could carry his personal-productivity load. Next week's setup: the two commands that ship this show.

Key takeaways:

• Try Claude Cowork for non-coding work: expense reports, document drafting, folder reorgs - it's the agentic surface for knowledge workers who don't live in a terminal.
• Skills are packagable. If a Cowork workflow works for you, the same .md spec + scripts/ folder + resources/ folder ships to your team.
• Skill quality is in the context. Examples and reference docs in resources/ are what make a skill reliable, not just a sharp prompt.
• The 'last 10%' is the human pass. Let the agent do the bulk; show up to shape, edit, and approve.
• You can stream this show from anywhere - iPad over Tailscale + tmux works fine. The setup is portable on purpose.

Watch the video version on YouTube · Full show notes, transcript + takeaways

Sash walks through a multi-agent deep research workflow he built inside Claude Code after getting burned by context-bloat and hallucinations in Perplexity and ChatGPT deep research. The system splits the job across four named agents: Oracle plans the research and decomposes a topic into angles, Hermes agents run one-per-angle in parallel to collect raw data points (with web search plus EXA semantic search), Athena applies the academic CRAAP framework - currency, relevance, authority, accuracy, purpose - to grade every data point, and Scribe (the only Opus agent in the chain) writes the final 20-30 page synthesized report.

The live demo researches AI agent adoption in knowledge work. While Hermes fans out five parallel agents, Sash and Chris dig into the model-selection tradeoffs he learned the hard way: Haiku was too weak as a research agent, Opus as the analyst burned tokens without beating Sonnet, so only the final writer stays on Opus. A concrete data point surfaces mid-run - Microsoft Copilot sits at 15-16M paid seats but only 35.8% active usage, meaning 64% of purchased seats are dormant. Education is the number one enterprise response to AI right now, not restructuring.

Chris connects the workflow to his own future-thinker agent experiment - a weekly check against obsolescence risk before building anything new - and Sash confirms the framework generalizes to market, strategy, or any research where the data exists on the web. The honest caveat: this workflow is token-heavy and has to be used strategically, not casually.

Key takeaways:

• Split deep research into discrete agents (plan / fetch / evaluate / write) so each context window stays clean - that alone cuts hallucinations dramatically.
• Pick models per-agent role, not per-project. Sonnet is good enough for planning, research, and analysis; reserve Opus for the final writer where prose quality matters.
• Try Sonnet 4.6 before reaching for Opus 4.5 - benchmarks are comparable at roughly half the token cost.
• Grade sources with an explicit rubric (CRAAP: currency, relevance, authority, accuracy, purpose) so only high-quality data points make it into the final report.
• Deep research is a strategic tool, not a daily-driver. It burns tokens - run it when you need depth, not when a web search would do.

Watch the video version on YouTube · Full show notes, transcript + takeaways