
Sign up to save your podcasts
Or


Chris and Sash spend this episode working through a problem most enterprise leaders already know exists but haven't acted on: employees running AI tools the company never approved. They define Shadow AI plainly - using a model or AI system your company hasn't sanctioned to do work - and draw a direct line from the old Shadow IT problem (pulling data into a personal Dropbox) to the new one (uploading confidential documents to a personal Perplexity or OpenAI free subscription with model training not disabled). The key difference they land on is that with Shadow AI, there's always a third party involved from the jump, and the exposure doesn't stay contained.
Sash makes the stakes concrete: run OpenClaw on your home Mac, plug in your company email, and you now have a fully autonomous always-on agent with access to everything - and the people most likely to do this are executives, the exact employees carrying the most sensitive data. Chris connects this to his BI background - Shadow IT in Power BI meant bad analysis on a local Excel file, low stakes. Shadow AI means confidential strategy going into a free-tier model and potentially becoming training data for a competitor's next GPT.
The back half of the episode is where it gets actionable. Sash's rule for agent governance: no agent runs in production without a harness that lets you trace it, period. Chris pushes the parallel to how enterprises managed the cloud migration - the same people/process/technology pillars (ITIL, NIST, ISO) apply here, just moving 10x faster. Both agree banning doesn't work - the more you restrict, the more people find workarounds - and that governed AI means giving employees the tools they actually need, with guardrails in place, not cutting off access and waiting for the breach. The episode closes with a preview of week four: skills as institutional knowledge, and how deploying consistent agent skills across a team is how you get predictable costs and consistent outputs.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
This is the re-record of episode two of the AI for Enterprise series - the first take went out with Sash's audio muted, so Chris and Sash ran it back. The topic is the one landing in every CFO and CTO inbox right now: why AI token budgets are blowing up and what to actually do about it. The catalyst is real - Uber gave engineers $1,500 a month of API budget and the whole company burned its entire year's allocation in four months. The point Sash keeps returning to is that an AI budget cannot be a single line item. The money has to go across people, process, and technology - rethinking workflows and re-skilling teams, not just paying for tokens.
The spine of the episode is a model for enterprise AI spend split into three workloads, each with a different cost curve. Chat is table stakes: 80-90% of an organization gets incremental productivity from browser-based assistants, and that cost is trending to zero (Microsoft M365 Copilot, free chat tiers). Coding carries the highest and most defensible spend, because software ROI is a solved measurement problem - faster features and shipped products tie straight to revenue, so the high token output is justifiable. Agentic is the fuzziest and most dangerous: agents are non-deterministic, run a lot of background work, and if you are not watching the meter one stuck long-running agent can burn the budget overnight. Sash's cautionary number is a real one - an agent that got stuck in a loop ran up a $35,000 API bill.
The practical guidance is concrete. Start everyone on $20 plans, detect power users from real usage patterns, and use plan-plus-usage as a middle tier before jumping to the $100 5x plans. Build every production agent with an eval harness and a kill switch, and set hard token and time budgets before you deploy. For coding and agentic volume, take frontier-model risk seriously - if Opus or GPT gets turned off tomorrow, teams running production processes on it are stranded - so pair a frontier strategy with an open-source one: self-host a strong open model (Qwen 32B fits in 24GB, plus Kimi K2 and GLM) on your own hardware, controlling both cost and risk. This is the cloud-era dual-provider playbook applied to models. It closes on the phrase that names the show: own the harness, run a powerful open model, harness in the loop. Tools like Codex Bar (Peter Steinberger) for token monitoring and Paperclip for per-agent budgets and auto-kill are where the governance layer is starting to form.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Chris opens this episode - the first of a four-part AI for Enterprise series - with a challenge to the room: Responsible AI is the part of every AI presentation where people pull out their phones. Not anymore. The regulatory environment has shifted, and a $35 million EU AI Act fine has a way of making even the most skeptical CIO lean forward. Chris draws directly from his time at Microsoft, where he presented the company's OpenAI partnership to enterprise executives and got deep into how Microsoft embedded Responsible AI into every engineering group, reporting to Satya's ELT.
The core of the episode is Chris walking through Microsoft's six Responsible AI principles - fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability - and showing how he has applied that same structure inside his own personal build system, TheGrove. The key moment is when he reveals that he runs a Responsible AI agent as a mandatory gate in his SDLC: after Red Team and CTO architecture review, Responsible AI must sign off before any feature ships. More pointedly, he has blocked builds from ever reaching a development environment because they failed to satisfy all six principles. He acknowledges the tension directly - a Claude agent evaluating a Claude-built plan is not an objective reviewer - which is precisely why the flag goes to him for human sign-off, not automatic rejection.
Sash grounds the conversation in the practical cost argument: the cost of doing this right now is not close to the cost of a fine. Chris brings in two vendor-neutral reference points - the NIST AI Risk Management Framework as a non-Microsoft alternative, and Azure AI Content Safety as a low-cost front-door filter for prompt and response classification across hate, violence, jailbreak, and hallucination categories. The episode closes with a tease of what is coming: EP.014 on token maxing and EP.015 on shadow AI, with the series building toward a full enterprise AI governance picture.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
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:
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:
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:
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:
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:
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:
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:
Watch the video version on YouTube · Full show notes, transcript + takeaways
From the publisher's feed