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:

• Do the modernization work first. Cloud, data, networking, and security foundations are what make a generative AI program possible, and skipping them is the same mistake teams made pushing BI projects ahead of data cleansing.
• Budget for team member modernization, not just technology modernization. The hard part is people reinventing how they work, and that is a change management problem rather than a tech problem.
• Fix your measurement before you add AI. If your KPIs are not instrumented well today, proving generative AI value on top of them gets harder, not easier.
• Match the tool to the problem. Deterministic automation and RPA still solve plenty of things more cheaply and more reliably than a frontier model, and orchestration plus observability matter more than horsepower.
• Use skills to put determinism back into agent work. Define the pattern once so the process runs the same way every time, and expect the good ones to graduate into automations.
• Ship tools that make someone's day measurably easier and adoption becomes organic. Finding an answer in ten seconds instead of two and a half minutes is the kind of win a frontline team feels immediately.

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:

• If you publish AI-assisted writing, disclose it yourself in the footer or byline rather than waiting for a detection tool to flag it later - both hosts already do this and treat it as the safest default under the new mark.
• Don't assume a light-touch AI pass (grammar check, fact-check, translation) is exempt from the watermark - the mark applies to anything that passed through Claude, not just fully AI-authored text, so budget for that before you rely on it staying invisible.
• Know that the watermark is currently defeated by running Claude's output through a second model to rephrase it - if you or your org are planning to lean on detection for policy or trust decisions, that gap matters today.
• Watch for Anthropic's promised public text-detection API - that is the step that turns "a mark exists" into "someone can actually check for it," and it is not live yet.

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:

• If something about your agent setup keeps nagging at you ("is this friction normal?"), treat it as signal - spin up a parallel instance with a stock model and no custom harness, and compare results before assuming your custom setup is still worth its context budget.
• When you retire an agent or harness, don't delete its memory - archive it as a tombstoned "V1," ask it what it wants carried forward into "V2," and start clean from there.
• A shared, synced memory layer (wiki-style, read-only mirrored across machines) matters more than which harness you pick - organize it so every agent can actually find what it needs, not just access it.
• Watch for vendor lock-in risk directly, not just cost: geographic restrictions (Fable's brief US-only limitation) and terms-of-use constraints (routing autonomous-harness traffic through Anthropic directly) are real reasons to keep a second provider live.
• Scope what an always-on agent can do to itself - Rene's agent needed a human to step in and grant runtime access precisely because it was walled off from troubleshooting its own failures, which is what kept a bad actor or prompt injection from having free rein.

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:

• Put the human gate where the money starts. Chris approves the script on Telegram before the produce skill runs, because everything upstream of that point is free and everything downstream costs real API spend.
• Keep orchestrating skills free of logic. Have them call subskills instead, so you can change the voice step without editing the whole pipeline or hoping the model does not break something adjacent.
• Track cost per minute of finished video as your KPI. Chris lands around 50 cents per minute for a story and a little over a dollar per minute for a product demo, counting images, voice, digital twin, and music.
• Deconstruct before you automate. Write down the whole pipeline from research to release first, then turn each phase into its own skill with its own context, instructions, and tools.
• Taste is not a prompt, it is time. The way to get output that matches your creative vision is to iterate and review repeatedly, and to define what good looks like in words the machine can act on.

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:

• When an agent underperforms, change the harness before you change the model. A controlled study put the capability difference at roughly 8x with the model held constant, so the scaffolding is usually where the leverage actually is.
• Pick the lowest rung of the ladder that does your job. Chat, session-based agent, always-on. Capability and fragility climb together, so buying capability you do not need means buying failure modes you did not want.
• Instrument always-on agents for silent failure before you rely on them. OpenClaw dying quietly on a background task is invisible until you deliberately enable traceability, and an agent that fails without telling you is worse than one that does not run.
• If you fork an always-on harness, you own its updates. Chris forked Hermes, customized it, and then could not take a safe update. That is the real price of the control, and it is not payable in AI time.
• If you are at a company weighing frontier model dependency, start scoping what your own harness would look like now. The argument for it is cost and concentration risk, not capability, and the tooling and teaching around harness engineering is arriving quickly.

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:

• Constrain what the agent is allowed to generate (one paragraph, not a whole email) so the review step stays fast and the failure mode stays small.
• Log the diff between agent draft and human-sent output. That diff is the training signal for reducing future edits, not just an audit trail.
• A "blind spot" check (comparing personal vs. work calendars) is a simple, high-value use of an always-on agent that has nothing to do with generation quality.
• Feed an AI writing tool your own transcripts and sent-item history if you want it to actually sound like you, not a generic assistant voice.
• A safety-mode toggle on any agent action that can reach a real customer is a cheap insurance policy against an expensive mistake.

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:

• A skill is a folder with a skill.md (plain-English instructions) plus optional reference files, templates, or scripts. No code required to create one.
• Use an agent only when a skill would overflow the context window. For everything else - outreach sequences, briefing, battle cards, brand copy - a skill is cleaner and cheaper.
• Claude Teams and Claude Enterprise let you provision skills at three tiers: owner-only, team-level, or org-wide. Marketing gets marketing skills. Sales gets sales skills. You can centrally update and evaluate them.
• Let Claude build the skill for you. Run the process in chat, iterate until the output is right, then ask Claude to package it into a skill. It reads the conversation history and produces the skill folder.
• Skills created in Claude chat and Claude Cowork are interchangeable. Skills created in Claude Code use a different packaging mechanism and will not appear in Cowork - you may need to recreate them.

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

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:

• Define Shadow AI clearly for your org before you try to govern it: any AI model or system not approved by the company, used on company work, with a third party receiving your data.
• The real risk isn't the casual browser user - it's the executive running an autonomous agent connected to their company email on a personal subscription.
• Banning doesn't work. Employees who find AI useful will route around restrictions. Give them sanctioned tools with guardrails instead.
• Every agent running in production needs a monitoring and evaluation harness that lets you trace what it's doing. No exceptions, no matter how small the agent.
• Apply the frameworks you already know - ITIL, NIST, ISO, data classification, sensitivity labels - to AI governance. The technology is new; the governance pillars are not.

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:

• Split enterprise AI spend into three workloads before budgeting - chat, coding, agentic - because each has a completely different cost curve and risk profile.
• Coding is the highest and most justifiable spend; its ROI is measurable because it ties directly to shipped features and revenue. Chat is trending toward zero; agentic is the fuzzy, dangerous one.
• Do not deploy an agent without a hard token/time budget, an eval harness, and a kill switch - one stuck long-running agent ran up a $35,000 API bill.
• Tier your plans by real usage: start everyone at $20, detect power users, and use plan-plus-usage as a middle step before the $100 5x plans.
• Pair a frontier-model strategy with an open-source one. Self-hosting a strong open model (Qwen 32B, Kimi K2, GLM) on your own hardware controls cost and removes the risk of a frontier model being turned off.
• Monitoring is the whole game - you cannot budget what you cannot see. Bring in token monitoring (Codex Bar) and a governance layer (Paperclip) with per-agent caps and auto-kill.

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:

• Responsible AI governance is cheaper to build in than to bolt on after a violation - the EU AI Act can fine organizations up to $35 million for major infractions.
• Microsoft's six principles (fairness, reliability and safety, privacy and security, inclusiveness, transparency, accountability) are a practical starting checklist for any enterprise building AI systems.
• Run Responsible AI review before build, not just after - Chris gates features at the planning stage and has stopped builds from reaching dev because they did not satisfy all six principles.
• If you prefer a vendor-neutral framework, look at the NIST AI Risk Management Framework - same governance intent, no Microsoft alignment required.
• Azure AI Content Safety is one of the cheapest Azure SKUs and acts as a configurable front-door filter for LLM inputs and outputs - covering hate speech, jailbreaking, prompt injection, and hallucination detection on a 0-7 severity scale.

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