
Sign up to save your podcasts
Or


Chris has spent months trying to get his agents to talk to each other, and this episode is the honest tour of three attempts: what broke, what held, and what he actually runs now. He frames it against four trust levers borrowed from how a person climbs through the ranks - human IS the loop, human IN the loop, human ON the loop, human OUT of the loop - and pins the current shift to Gary Vaynerchuk's 15/80/5 model: own the first 15 percent of an initiative, get out of the way for the 80 in the middle, come back for the last 5.
Attempt one was AgentMail, a webhook service that bills itself as Gmail for agents. Silas, Chris's Hermes chief-of-staff agent, had his own inbox and would email Neo, the coder agent, to hand off work. It worked on vibes. Conversations died silently after about the third message, and worse, they died without telling Chris - the failure mode every manager recognizes. Sash draws the distinction that explains it: these are separate Hermes profiles, peers rather than sub-agents under one parent, so there is no hierarchy to carry the handshake. Attempt two, Hermes's Kanban feature, fixed exactly that. Kanban is really a wake-up mechanism with a native acknowledgement handshake: the orchestrator posts a task to another profile's board, that profile gets a heartbeat, picks it up, and links its subtask back. Chris runs it autonomously at 4 AM against a backlog board, with a Postgres ledger tracking the traffic. It still runs, and it still only works between Hermes profiles on one gateway.
The gap that Kanban could not close is that Claude Code is Chris's real building harness and it cannot clear its own context window. His SDLC runs the superpowers plugin - brainstorming on Sonnet, design on Opus, writing plans on Sonnet, then the build loop on Opus or Fable - and every handoff between those steps needed a human to clear context, relaunch, and switch models. That is the thing that killed autonomy. Grove Rooms are the answer: a dedicated tmux session, synced to the Postgres ledger, that Silas spins up and then drives. Silas watches for the spec file to be committed, types /exit, relaunches Claude Code in the same session on the right model, and kicks off the next skill, unattended. Chris answers the brainstorming questions, walks away, gets a notice when the room moves from plan to build, and comes back to review and run close. The next move he talks himself into on air is cross-harness: have Silas hand Claude Code's finished work to a Codex-backed agent for review before it ever reaches him, and eventually replace the whole arrangement with the native A2A protocol that Hermes, ElevenLabs, Copilot Studio, and Foundry Agents already speak.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Eric Brown, a Solution Engineer at Microsoft focused on Copilot and agents, joined Chris and Sash to walk through Copilot Cowork the way he demos it for enterprise customers. The framing up front: the bottleneck in most organizations was never a lack of knowledge, it is coordination across email, meetings, chat, and scattered documents - and Cowork is built to act as an agentic teammate inside that mess rather than another place to search.
Eric ran a live screen share showing the difference between Copilot Chat (single question, single response) and Cowork (connects to tools and data, reasons, and executes multi-step work). A big piece of what makes that possible inside Microsoft 365 is Work IQ - the graph layer that already knows a user's files, meetings, emails, and chats, now paired with an LLM that can reason over it. Eric was clear that Cowork's access is bounded by the same permissions the user already has in Exchange, SharePoint, and OneDrive - "your digital assistant only has access to the items that you have access to" - and described the governance posture as wanting to build "a casino, not a prison," enabling exploration inside real guardrails rather than locking things down entirely.
The back half moved into automations: Eric used voice to ask Copilot to pull meeting transcripts off his calendar and generate a recurring daily digest, live, showing the step-by-step planning Cowork does before it commits to a scheduled task. Chris connected it to his own "orchestrator method" - define the end state with clarity first, then let the agent work backward into steps - and the conversation was headed into how Microsoft 365's credit system prices this kind of agentic work when the recording cut short.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Sash drives this one, and he does not start with the tool. He starts with the failure. He was running Claude Code across two Macs, so his first move was the obvious one: put his intelligence folder of Markdown context files in a git repo and sync it to both machines. That worked until it did not. Every session ended with a push he had to remember, and every session started with a pull he had to remember, and forgetting either one meant an agent was working from yesterday's truth. Then he added a Hermes agent on a Hostinger VPS, then revived an old OpenClaw agent on another one, and suddenly there were four agents and no shared understanding between them.
The fix was not better discipline, it was a different layer. Sash looked at Obsidian vaults and Karpathy's LLM Wiki before landing on gbrain, the open-source project from Y Combinator's Garry Tan, which Tan describes on the repo as "the production brain behind my OpenClaw and Hermes deployments." gbrain sits on top of the git repo as a semantic layer: it chunks the Markdown, indexes it into Postgres with pgvector, and exposes an MCP endpoint agents can query. The git repo stays the durable source of truth and stays human-editable. What changes is retrieval. Instead of loading CLAUDE.md plus status.md plus decisions.md into every context window, an agent asks gbrain for the chunk that matches the task and pulls more only if it needs it. That is the moment Chris stops the demo to repeat it back, because just-in-time context is the part that actually changes a working day.
The second half is the part most people skip, which is access. Sash runs three agents against one brain with deliberately different permissions: Nuro is the only thing with write access to the git repo, Kyra has full read/write on gbrain but read-only on the repo, and Blaze can only read the course-related slice and cannot see client work at all. His framing is that this is not novel, it is just how you build an IT team - help desk does not get admin on the database, engineers do. Sash closes with the smallest version worth doing: if you run one agent and nothing always-on, hand the gbrain repo to Claude Code or Codex, point it at the files you already work in, and describe the thing your agent keeps forgetting.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Kevin Johnson - KJ - leads the AI and automation practice at Pinnacle Financial Partners, a bank that closed a merger of equals in January between two institutions north of $60 billion each. He has been doing this hand-to-hand since ChatGPT launched in November 2022. Chris and Sash brought him on to answer the question every enterprise team is quietly stuck on: what actually has to be true before generative AI works in production.
His answer is that almost none of it is about AI. Pinnacle's ability to move fast on generative AI traces back five or six years, to a modernization journey that ripped workloads out of a traditional data center, rebuilt the data and networking and security layers, and reorganized teams into pods around the new work. That unglamorous foundation is the reason the AI work has anywhere to land. KJ's sharper point is that the same modernization has to happen to people, and that half gets far less attention: reinventing yourself as a contributor after two decades of doing the job one way is hard, and the organizations that win will be the ones that move fluidly through that change. As he put it, that is as human as it gets.
The back half is about discipline. Value in generative AI is genuinely hard to measure, and KJ is blunt that if you are not already measuring your KPIs well, layering AI on top makes measurement harder rather than easier. He and Sash land in the same place on tooling: automation and AI are two different tools in the toolbox, deterministic solutions never actually died, and you do not need a cannon or a bazooka for a mosquito. Chris connects that back to skills as the middle ground - a way to get an agent to follow the same process every time, even when the wording varies - and notes how often his skills end up becoming automations. The advice KJ would give his 2023 self is not technical at all: get real leadership buy-in, make continuous innovation part of the DNA, and meet the organization where it actually is.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Anthropic started watermarking every piece of text Claude produces, worldwide, three days before this episode and Sash and Chris jumped on an unplanned morning show to work through what it actually does. The watermark has two parts: an invisible mark woven into the text itself, and C2PA metadata (the same provenance standard Microsoft and Google use) attached to generated artifacts like images and documents. It is not opt-in - Anthropic is required to ship it everywhere under Article 50 of the EU AI Act, the same transparency requirement that is starting to do for AI content what GDPR did for data.
The conversation kept circling one unresolved question: the mark does not distinguish between text Claude wrote from scratch and text a human wrote and ran through Claude for a light edit, a fact-check, or a translation. Both cases get flagged the same way. Sash pointed out the mark also strips cleanly the moment you run the output through a second model to rephrase it, which means the ambiguity cuts both directions - it can wrongly implicate a human editor, and it is trivially defeated by anyone trying to hide real AI generation. Anthropic says a public text-detection API is coming, which is the piece that would actually make this enforceable rather than theoretical.
Both hosts landed on the same personal practice out of this: get in front of it and disclose AI use yourself instead of waiting to be caught by a detector. Sash already footnotes every newsletter issue as written with Claude Code; Chris said the episode convinced him to start doing the same with his own AI-generated text going forward.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Rene Charbonneau returns three months after EP.009 to report on the promise he made on his way out the door: refactor his AgentOS. He didn't refactor it. He blew it up. What started as a two-week attempt to untangle a ball of yarn he and Claude had built together turned into a full rebuild once he realized the old assumptions (a single hand-built harness, a builder-first workflow, memory scattered across machines) no longer held. The teardown included literally retiring his always-on agent, Jim, mid-project, and returning to rebuild the connection layer (SSH, approvals, skills) from scratch on a fresh machine profile.
The conversation centers on what Rene replaced the old setup with: less building, more configuring; a shift from Claude Code alone to a Hermes/OpenClaw split, backed by an LLM Wiki-style agentic memory layer (Y Combinator's G-brain) synced read-only across multiple machines so every agent works from one source of truth. He also dropped his Claude subscription from $200 to $20/month, using Hermes and OpenClaw against OpenAI instead, partly for cost, partly because routing agent traffic that way violates Anthropic's terms of use, and partly because watching Fable get geo-restricted in Canada made vendor lock-in feel like a real risk rather than a hypothetical one.
The back half zooms out to where this goes for non-technical users: Microsoft Scout and rocket-branded turnkey "agent PCs" (Auto, VioLoop) as the consumer packaging layer for the same OpenClaw/Hermes stack the hosts run by hand, POKE as a prepackaged agent you negotiate with over iMessage, and a BYOA ("bring your own agent") framing for how enterprise hardware procurement might look in five years. Chris teases next week's guest, Kevin Johnson of Pinnacle Financial, who will cover the enterprise version of this same journey: foundation-first before AI, not AI bolted onto ungoverned data.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Chris opened the show with roughly thirty seconds of himself that was not himself. The voice, the face, and the script were all generated, and the reveal was the point: the pipeline that produced that cold open is the same one that produces the trailer, the highlight reel, and the product demos. He then kicked off two real jobs live on stream, the EP.020 trailer and an iLink product demo, and let them run in the background while he and Sash talked through how the machinery works.
The shape of the pipeline is the same everywhere Chris uses it. A research skill finds material inside a defined niche. A script skill drafts it, grounded in enough of his own writing that the draft comes back sounding like him rather than like a model. A critic agent checks the draft against the storytelling rules he cares about and sends it to Telegram for approval. Only after that gate does a produce skill start spending money, calling ElevenLabs for voice and rendering images. A release skill then schedules the finished video to YouTube against a defined cadence, cuts the Shorts, builds the Facebook and Instagram posts and reels, and pushes the audio to the podcast RSS feed. Nothing in the orchestrating skills holds logic; they call subskills, so a single stage can be changed without touching the rest.
Sash's framing for all of it was deconstruct and delegate. His argument was that a complex multi-step task should never be one pipeline, and that the three things that decide whether long-running agent work succeeds are context, instructions, and tools, set up per piece rather than once globally. He tied it back to spec-driven development: nobody writes production software without planning the user journey and the features first, and agent pipelines deserve the same treatment. The honest moment came at 29:21, when the product demo Chris had kicked off did not finish end to end despite testing clean three times beforehand. Nobody cut away. He showed a previously rendered demo instead and moved on, which is roughly the whole thesis of the show.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Sash drove this one, and the framing he opened with does most of the work: a model is a faucet of intelligence, but a faucet on its own does not plumb a house. An agent is a model plus a harness, and the harness is the environment the model actually runs inside. It is the app. The chat window is a harness. Claude Code is a harness. Hermes and OpenClaw are harnesses. What the harness supplies is everything the model cannot supply itself: tools, memory, skills, and a scheduler. Take those away and an agent collapses back into a chatbot.
The useful part of the episode is the ladder Sash laid out. Chat sits at the bottom, the simplest harness there is, with almost nothing to break. A session-based agent harness like Claude Code or Codex sits above it, capable of pulling tools, running skills, spawning subagents, and looping. Always-on harnesses like Hermes and OpenClaw sit at the top, waking on a schedule, reading a task list, and working without a human in the session. The catch is that fragility climbs right alongside capability. Chris and Sash both hit it: OpenClaw dying silently on background tasks with no signal until you go turn on traceability, and Chris discovering he could not take a clean update after forking Hermes, because customization is exactly what makes an always-on harness yours and exactly what makes it yours to maintain.
The number worth carrying out of the episode is 8x. Sash cited a controlled study showing the right harness multiplied agent capability roughly eightfold with the model held constant. That reframes where the leverage is. Chris landed the analogy that ties it together: the harness is to agents what retrieval augmented generation was to GPT three years ago, the surrounding machinery that turns a generic model into something grounded in your context and useful on your problems. Both hosts expect enterprises to start building their own harnesses, partly to run cheaper open-source models and partly to hedge the cost and geopolitical exposure of depending on frontier providers. Harness engineering is already showing up as a taught discipline, which is usually the sign that something has stopped being a niche.
The show also changes format starting next week: YouTube instead of LinkedIn, Wednesdays at 2 PM ET instead of Fridays, and 25 minutes instead of 15.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
Chris drove this one solo-demo style, no guest, closing out the AI-for-enterprise arc for now to make room for other topics. He walked through TheGrove, his personal agent system, and specifically the Follow-up Engine: an agent that reads meeting notes and call transcripts and drafts the follow-up email in his own voice. The demo used a sanitized mock transcript (a made-up company, "Harborline Financial") - the agent identified attendees, pulled out three to five commitments, let Chris reassign a miscategorized commitment to the right person, and then drafted a follow-up email trained on hundreds of his real emails and Teams messages for tone, format, and sentence length.
The core mechanic: the agent only ever produces a draft. It lands in a review gate before anything sends, and the system logs the diff between what the agent wrote and what Chris actually sent - word changes, tone changes, punctuation - so it keeps learning from his edits over time. Every Friday he gets a "Follow-up Friday" digest on Telegram: how many emails sent, average edit rate, how many went out verbatim. The goal isn't a smarter agent, it's fewer edits, earned one draft at a time. Chris also showed the daily morning digest (calendar, blind-spot detection between work and personal calendars, overdue commitments) and the one-click "action debrief" summary send, which has a safety-mode toggle so it can't accidentally reach real customers.
They closed by teasing next week's episode: the harness (not the model) is often what actually determines agent capability, and they're breaking down the spectrum from chat to agentic to always-on autonomous systems.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
This is episode four of the AI for Enterprise series and the most practical one yet. Sash walks through what Claude skills actually are - a folder with a skill.md file written in plain English, plus any reference files, templates, or scripts the workflow needs. The standard was released by Anthropic in November 2025, and within two months 16 other vendors adopted it, including Microsoft (it shows up as skill.md in M365 Copilot Agent Builder). That portability is the point: a skill you write for Claude today can move to Replit or Cursor unchanged.
The bulk of the conversation is about why skills beat agents for most enterprise use cases. Sash's rule of thumb is direct: only reach for an agent when a skill would overflow the context window and lose quality. Otherwise a skill running inside Claude chat or Claude Cowork delivers consistent, predictable output at predictable token cost - which is exactly what you need when ten SDRs or twenty marketers are all hitting the same process. He showed his own skill library live: a simple create-doc skill with just a skill.md, versus a multi-agentic deep-research skill with four reference files providing process context.
Chris tied it to the enterprise governance angle the series has been building toward. Skills are a pro-code-to-low-code bridge: your AI architects build and vet the skills, the Centre of Excellence promotes them, and frontline workers get approved, consistent AI behavior at scale. Chris also confirmed this entire show - the episode pipeline, website updates, everything - runs on orchestrating skills that call other skills. The episode closes with a tease: the series is getting a fifth week, and they're bringing in a guest from the enterprise world.
Key takeaways:
Watch the video version on YouTube · Full show notes, transcript + takeaways
From the publisher's feed