AI In Microsoft 365 Episodes

Your AI isn’t broken — your digital city is lying to it. In this noir-style podcast episode, we pull back the curtain on why Copilot, search, and enterprise AI tools hallucinate, misfire, and surface the wrong answers even when the data “exists.” The culprit isn’t prompts or models — it’s information architecture. Through a detective’s lens, we explore how broken site structure, weak metadata, sloppy permissions, and chaotic navigation turn intranets into cities without streets. You’ll learn why thin content disappears from the index, how bad hubs confuse retrieval, and why AI can’t ground answers without clear signals. This episode breaks down the three pillars that actually fix AI accuracy: structure, semantics, and governance. From content types and term stores to search schema and permissions, we show how building a clean blueprint transforms Copilot from a guesser into a reliable informant. If your AI sounds confident but wrong, this episode explains exactly why — and how to fix …

You think Microsoft Copilot knows your business. It doesn’t—and that blind spot is costing you real decisions. In this episode, we expose the uncomfortable truth about Microsoft 365 Copilot: out of the box, it only sees surface-level data like emails, chats, and documents—not the systems that actually run your business. No Salesforce pipeline. No ServiceNow incidents. No proprietary APIs. Just a narrow slice of context that leads to confident but wrong answers. We break down why Copilot is blind by default, how grounding really works, and why AI without secure access paths will always hallucinate. Then we show you the fix: building enterprise-grade Copilot agents using Copilot Studio and Teams Toolkit, wired directly into your real systems with governed identity, least-privilege access, and full audit trails. You’ll learn: How Copilot “sees” data—and why most organizations misunderstand it The difference between AI theater and production-ready enterprise agents How to grou…

Your AI isn’t broken, it’s telling the truth about your mess. In this episode, we expose why Copilot, search, and AI agents give confident but wrong answers inside Microsoft 365 and how the real problem isn’t prompts, models, or tools, it’s governance. You’ll hear how permission drift, orphaned Teams, ROT data, shadow sites, and overzealous restrictions quietly poison AI grounding, causing hallucinations that sound just like you. Through real admin stories and before and after examples, this episode explains why AI reads structure, permissions, labels, and residue, not intent, and why cleaning the house changes everything. We break down the five governance binds that actually fix AI accuracy: lean information architecture, lifecycle management, sensitivity labels, DLP, and retention, all working together as a repeatable ritual. If you want Copilot answers that are current, precise, and trustworthy, this episode shows why governance is the foundation of AI truth and how to start fixing…

Shadow IT didn’t disappear, it evolved into AI agents quietly moving your data faster than your controls can see. In this episode, we break down how AI agents, Copilot Studio bots, and Power Automate flows are becoming the new Shadow IT inside Microsoft 365. What starts as productivity quickly turns into a governance and security nightmare when agents run with human identities, oversized Graph permissions, and no lifecycle controls. We explore how overshared SharePoint data, unmanaged browser-based AI tools, and third-party connectors expand your attack surface without triggering traditional security alarms. You’ll learn why Entra Conditional Access alone doesn’t protect agents, how delegated permissions quietly create ghost service accounts, and where Purview DLP often fails in real-world AI usage. The episode balances the real productivity wins agents can deliver with the hidden risks most organizations overlook. It closes with a practical reference architecture, a clear risk sco…

The cursor freezes. The event stream flatlines. Silence gets loud. That’s how customer journeys fail in the summer—quietly, invisibly, and at the worst possible moment. Summer traffic is deceptive. Intent spikes, teams run lean, and automation is supposed to carry the load. But when journeys rely on assumptions instead of evidence, silence replaces action. High-intent signals appear—pricing page views, repeated add-to-cart events, long dwell times—yet no email, SMS, or task ever fires. No alert triggers. No error appears. The journey simply dies between intent and action. The problem isn’t lack of data or channels. It’s missing structure. Over-automation without guardrails kills more journeys than under-automation. Consent conflicts, stale segments, misfired triggers, and absent evaluation records create a perfect summer storm. Dashboards glow green while revenue leaks quietly out the back door. To protect performance during peak summer months, every real-time journey needs p…

Ever trusted an AI answer that felt certain, then realised you couldn’t prove where it came from? This video is a forensic walkthrough of how single agents hallucinate, leak data, drift off stale indexes, and fail every audit that matters – and how to fix it with a multi-agent reference architecture in Microsoft 365. You’ll see exactly how SPFx + Azure OpenAI + LlamaIndex chains go wrong: weak RAG retrieval, no rerank, ornamental citations, prompt injection, over-privileged Graph connectors, and stale SharePoint indexes. Then we rebuild the system with dedicated agents for retrieval, rerank, verification, red-team and blue-team policy, maintenance, and compliance, all fronted by Azure API Management and permission-aware Microsoft Search or Copilot retrieval. You’ll learn how to enforce chain of custody, log prompts and tool calls, require line-level citations, and replay answers on demand for regulators and boards. If you care about AI you can defend, not just demo, this is your bluep…

Dynamics 365 can be a filing cabinet or a growth engine—and most teams unknowingly build the cabinet. This episode shows how to turn Dynamics into a system that drives progress by removing friction, not adding features. Instead of treating go-live as the finish line, we focus on clarity, constraint, and monthly improvements that shrink cycle time and lift performance. You’ll hear how refining business process flows, tightening stages, and eliminating unnecessary fields immediately shifts user behavior and accelerates throughput. Real stories demonstrate how small changes—like forcing next actions, routing on save, and trimming approval chains—cut delays and restore momentum. We break down the habits of high-performing Dynamics teams: weekly triage of real user pain, 30-day release cycles, action-oriented views, and product ownership that prioritizes impact over noise. By the end, you’ll see how process, data, and people work together to turn everyday work into measurable progress. The…

Tired of chatbots that answer Intune incidents with poetry instead of fixes? In this episode, we go hands-on with Azure AI Foundry and Semantic Kernel to build a mini, self-healing, governed multi-agent system for enterprise IT. You’ll learn why single agents stall on real Intune, Entra ID, and Microsoft Graph workflows, and how planner, operator, reviewer, and concierge agents collaborate to deliver faster, safer automation. We break down patterns for tool-driven remediation, identity-scoped actions, content safety, and observability, then apply them to three real-world scenarios: ghost device cleanup in Intune, truly zero-touch onboarding, and automated BitLocker security hardening. Along the way we mix small language models with GPT-4-class reasoning models to cut cost, reduce hallucinations, and keep prompts short while still getting production-grade results. If you’re an Azure, Intune, or security engineer looking to turn AI agents into reliable teammates instead of risky toys, t…

You’re wasting AI on small talk. In this session I show you how to turn chatty models into hardened IT ops agents that actually fix incidents while you sleep. We wire Semantic Kernel, MCP, Microsoft Graph and Azure OpenAI with managed identity so agents can plan, act and auto-verify – without handing root access to a hallucinating chatbot. You’ll see how to slash MTTR, auto-resolve password reset tickets, drain bad builds, and roll back safely using tool schemas as “laws of physics,” not vibes. We’ll build a six-part agent molecule (persona, memory, planner, tools, policy, verifier) and drop it into real incident flows: 5XX spikes, canary failures, onboarding waves and weekend fire drills. If you care about uptime, sleep, and not turning your data center into glass, this is your blueprint: SK orchestrates, MCP connects, Foundry governs, managed identity contains – and your agents prove every action they take.

The night is thick with static inside your tenant, and the questions aren’t small anymore. Copilot can walk the clean, well-lit M365 streets — summarizing inbox noise, tightening your notes, finding what you already have permission to see. Fast, friendly, useful. But tone isn’t truth, and guesses don’t survive compliance. This episode pulls you into the alleys where real knowledge lives: stale PDFs, forgotten SharePoint stacks, file-server ghosts, wikis no one maintained. That’s where Copilot reaches its boundary — and where Retrieval Augmented Generation starts. RAG becomes the librarian with receipts, dragging ground truth from your own systems, forcing citations, refusing to bluff. We map when Copilot is enough, when you must build a pipeline, and why teams explode cost, tickets, and trust by confusing the two. A secret step makes the whole discipline 10× easier — and we go there. If your world runs on proprietary policy, SOPs, baselines, and high-stakes questions where wrong…

AI agents are shipping faster than your change control, and they’re carrying master keys to your data. This talk rips into how LangChain4J and Copilot Studio quietly turn “helpful copilots” into data-leaking, over-permissioned shadow admins with no audit trail. You’ll see exactly how prompt injection, over-scoped connectors, and missing logs create reportable incidents, and how strict schemas, per-agent identities, and real DLP stop the bleeding. The core move most orgs skip: give every agent its own locked-down identity, no shared creds, no tenant-wide scopes, and treat it like a very dumb, very powerful user you have to restrain by design.

In this episode of The M365 Show we investigate a familiar but often misunderstood failure pattern in enterprise AI: GPU costs rise, throughput collapses and latency becomes unpredictable, even though the dashboards look healthy and the models appear to work. Instead of blaming parameters or architectures, we treat the problem as a forensic case and follow the evidence through the entire compute pipeline. We walk through a realistic Stable Diffusion workload under concurrency, with strict P95 latency objectives and GPU hardware that looks perfectly adequate on paper. From there, we trace how silent CPU fallback in ONNX Runtime, subtle version mismatches across CUDA, cuDNN, TensorRT and ONNX Runtime, and container misconfiguration combine into a single pathology that turns an accelerator into an expensive heater. The system continues to return correct outputs, but at 10 to 30 times the expected latency and with a fraction of the intended throughput. Building on that, we construct…

Tired of “smart” AI agents doing dumb, dangerous things in your Microsoft 365 tenant? This episode shows you the one architectural move that turns flaky prompt-powered agents into reliable, auditable systems: a pre-execution contract check that blocks bad behavior before it ever hits your data. We walk through how to separate LLM cognition from real-world operations, why executors and validated workflow graphs beat prompt hacks every time, and how to wire this into Microsoft 365 Graph, Azure OpenAI and Copilot Studio without creating a compliance nightmare. You’ll see how a validator proves three things before any tool call runs: the capability is real, the caller actually has permission right now, and the outcome is feasible and verifiable within strict data boundaries. No “trust the model,” no silent partial failures, no hallucinated tools. Instead, you get schema-checked JSON, idempotent executors, policy-enforced allow lists, human checkpoints as first-class workflow nodes, and…

Why do so many Microsoft 365 Copilot projects fail — even when the prompts look fine? In this episode, we explain why the real issue is not prompt engineering, but context engineering. Most AI failures are not model failures. They are context failures. When Copilot lacks structured, governed, and relevant information, it produces inconsistent, low-quality, or misleading results. Context Engineering goes beyond writing better prompts. It is the systematic design, management, and governance of all information your Copilot has access to — ensuring accurate, stable, and trustworthy outputs. We break down what context engineering really means in Microsoft 365 environments, why it matters for enterprise AI adoption, and how to design Copilot solutions that scale reliably. If you want consistent Copilot results instead of AI randomness, this episode is essential.

Summary: In this episode I explain why “1,400+ connectors” is a vanity metric and compare Power Automate vs Azure Logic Apps for real enterprise integration. We dig into throttling, throughput, vNet and private endpoints, Azure Arc hybrid, AI agents with Azure Functions, and give you a simple decision rule: Power Automate for departmental M365 convenience, Logic Apps for high-volume, governed, hybrid workloads.

n this episode, we put Microsoft 365 Copilot’s Workflows Agent head-to-head with Power Automate and ask the uncomfortable question: are your painstakingly hand-built cloud flows now the slow, expensive option? We break down where conversational, intent-driven automation beats traditional designer-driven flows for everyday work across Outlook, Teams, SharePoint, Planner and Microsoft Graph—and where Power Automate still absolutely owns the room. You’ll see real-world use cases—approvals, data sync, incident triage, CRM updates and IT onboarding—timed and dissected for build time, error surface, governance, and licensing cost. We unpack DLP, environments, auditability, SLAs, and why hybrid patterns (Agent front, Power Automate spine) are where the real ROI hides. By the end, you’ll know what to keep in Power Automate, what to move to Workflows Agent, and what to retire entirely—so you stop hoarding fragile flows and start shipping automations that match how your org actually works.

Worried your SharePoint or Copilot agent is “hallucinating” data leaks? In this episode, we unpack why that’s almost never the model’s fault and almost always your permissions and scope design. You’ll learn how SharePoint and Microsoft 365 agents actually see your data through Microsoft Graph, why overscoped knowledge sources plus permissive inheritance turn into accidental disclosure at machine speed, and why grounding does not equal a security boundary. We break down a practical mental model for agents – user persona plus retrieval filters, gated by permissions, labels, and Purview DLP – and show exactly how an agent can quietly stitch together truths from adjacent libraries you never properly isolated. From there, we go deep into the four control planes that stop bleed without killing usefulness: scoping knowledge sources at the library level with strict metadata and multiple narrow, specialized agents instead of one encyclopedic monster; breaking SharePoint inheritance where it…

This episode rips apart the illusion that “Copilot training” is a workshop, a slide deck, or a single rollout campaign. It starts with a familiar pain: you trained users on Microsoft Copilot, pinned decks, hosted Q&As, ran office hours—and your help desk ticket queue still grew. Users got smarter for 24 hours, then went straight back to asking, “Which Copilot do I use?” and “Is this safe?” The episode argues that the core problem isn’t users, or even Copilot. The problem is that most organizations are trying to manage a fast-moving, AI-driven behavior engine with static training and scattered documentation. Without a governed, tenant-aware learning system, you’re not doing adoption—you’re role-playing a help desk. From there, the conversation reframes Copilot adoption as an information architecture and governance problem, not a training problem. Traditional one-off training creates “shadow training” everywhere: rogue slide decks in Teams, PDFs with filenames like “Ultimate Copilot …

Python is NOT the language of AI inside the Microsoft stack—and in this episode, I show you why that belief is quietly wrecking your Power Platform projects, inflating defects, and burning your budget. If you’re cramming Python into Power Automate, Power BI, Fabric, or custom connectors as “glue code,” this is your wake-up call. We break down why Python is amazing for analytics, ML, and Fabric notebooks—but a terrible choice for everyday orchestration inside Power Automate, Power BI Dataflows Gen2, Dataverse, and Microsoft 365. You’ll learn how Office Scripts (TypeScript-flavoured), Copilot, and agent-style orchestration (like type-agent) can write and run the glue for you, with typed contracts, native connectors, and AI-generated scripts that actually respect your schemas and governance. Instead of debugging brittle Python in Azure Functions at 2:14 a.m., you’ll see how to: Keep Python where it shines: Fabric notebooks, advanced analytics, ML. Use Copilot + Office Scripts to …

Out-of-the-box Microsoft Copilot sounds like a genius—but in real enterprises it’s a dangerously confident intern. In this episode, we expose where default Copilot quietly fails on the questions that actually matter: “Can I share this file?”, “Who’s on-call right now?”, “Is this HIPAA-safe?” You’ll see how generic, Graph-only Copilot ignores your DLP exceptions, regional SOPs, escalation paths, and legal memos—and why that’s how incidents are born. Then we show you the fix: plug your own specialist engine agent straight into Microsoft 365 Copilot Chat with a simple manifest upgrade. You’ll learn the retrieval + actions + guardrails pattern, how to wire Azure AI Search, internal APIs, and tenant controls, and the exact schema 1.22 tweaks (copilotAgents + customEngineAgents) that flip Copilot from smooth-talking generalist to hard-edged policy enforcer. The before vs. after is brutal: vague essays and hallucinated “best practices” turn into crisp, cited decisions, “Page now” butto…

Your Copilot rollout is probably going to flop—and it won’t be the AI’s fault. Most organizations treat Microsoft 365 Copilot like a feature toggle: light up licenses, send a heroic memo, run one training… and three months later MAU is a rounding error. In this episode, we expose the five hidden failure modes that quietly kill Copilot adoption: vague “be more productive” use cases, governance theater that stalls everything, launch-and-ghost comms, license confetti with no telemetry, and users who were never actually taught how to talk to the model. You’ll learn the brutal truth that deployment is not adoption, the week-one leadership decision that predicts your long-term MAU, and why your real product isn’t Copilot—it’s behavior change. We walk through the C4 prompting pattern (Context, Constraint, Critique, Continue), the 10/30/60 “Tuesday task” model that kills blank-page syndrome, how to stop governance panic without freezing the rollout, and a practical 90-day adoption playb…

SharePoint looks confident on the surface, but under the hood it’s drowning in duplicates, forgotten drafts, and every “final final V2” that ever existed. In this episode, we pull back the curtain on why your search results lie, why Copilot sounds smart while guessing, and how a quiet storm of rogue files destroys governance without anyone noticing. It’s not a storage problem, it’s a relevance problem, and the chaos is baked into human behavior—people hoard because delete feels dangerous. SharePoint obeys, versions multiply, and truth dissolves in a fog of near-identical copies that confuse ranking systems and derail compliance. This episode dives into the architecture that fixes the mess without breaking collaboration or scaring users. We redesign the entire content lifecycle using a SharePoint command, an Azure Function, Blob tiers that behave like a warehouse district, and a ledger that remembers everything you move. Search becomes sharper, Copilot stops hallucinating, and your …

Your SharePoint / Microsoft 365 document libraries are quietly killing productivity — and Microsoft already shipped the fix. In this episode, I show you how the NEW Doc Libs UX, Forms, Autofill and Copilot turn your “final_v3_REALLY_final.docx” graveyard into an intelligent workflow that actually guides work instead of hiding it. You’ll see how enhanced breadcrumbs, visible filter pills, board view and saved views slash “where did my file go?!” drama, and how one adoption-killing mistake in your forms is sabotaging everything. Then we flip the front door: idiot-proof intake with Forms, smart metadata from Autofill (reading time, abstracts, categories) and a simple triage routine that keeps your response folders from turning into purgatory. Finally, we weaponize Copilot inside Doc Libs: instant version comparisons, punchy abstracts, audio overviews and grounded Q&A that turns a file pile into decisions on demand. Implement the five switches from this episode and your library stop…

Your M365 AI agent isn’t failing because the model is bad—it’s failing because your plumbing is. This episode exposes why DIY agents that “work in dev” die the second real users and security show up. You’ll hear how app-only auth quietly nukes permission fidelity and audit trails, why stateless bots forget context the moment you add a second node, and how hand-rolled Teams/Slack/Outlook adapters create glitchy, untrustworthy UX that feels cheap and amateur. The host then reveals the real unlock: the Microsoft 365 Agent SDK as the non-optional backbone for identity, state, channels, and governance. You get act-as-user auth, durable conversation state across clusters, real adapters for Teams/web/Slack/Copilot, streaming that just works, and built-in hooks for Purview, DLP, Defender, and eDiscovery—so security says “yes” instead of “absolutely not.” If you’re gluing LangChain, SK, and custom tools together and hoping it passes review, this episode is the wake-up call: stop shipping…