CAIP Frontier Consultancy v3.0 · Foundry style

DO: Let the title hold for a beat. Read the subtitle out loud, that is the thesis.

SAY: Cloud and AI Platform partners are in a strange spot right now. Customers are buying AI. You are selling AI. And most delivery teams are still working the old way, documents written by hand, status decks assembled from five tabs, a week of onboarding before the first line of code. That gap is the opportunity. The tools you sell are the tools you deliver with. This session is about closing that gap.

DO: Section transition. Short. Move quickly into the next slide.

SAY: Before the tools, let's talk about the math. Why this matters to your P&L, not just your tech stack.

DO: Hold on the heading for a beat. Read each card in turn, do not rush. Watch the room, partners will nod at the one that fits them. Name it: 'I see the nods on demand.' Keep the cards up while you talk; they do the social proof work.

SAY: Before we open any decks, three things we keep hearing from partners. First, talent. Your best consultants are spending a quarter of their week on the boring work. That is where your margin should be sitting. Second, demand. Customers are not asking if agents fit, they are asking how many they can buy. Your pipeline is moving faster than your staffing model. Third, risk. Modernisation projects are long and expensive, and the outcomes are not guaranteed. Every long project is a bet. If one of these feels like your team, you are not alone. If all three feel like your team, this session is for you.

DO: Optional opener: run a 2-min Menti poll, "Where does your team spend the most non-billable time?" Documentation / research / scheduling / manual tasks. Reveal results, then move to the three stats. Land on the Fellowmind callout, name the partner, name the agent, point at the link. That is the proof.

SAY: Sixty to eighty hours per engagement on documentation and admin. That is a full consultant-week, buried inside every project, before you bill a single dollar of AI work. Fifteen percent of consultant time never reaches an invoice. The third number is the one moving fast: the same reports now show twenty-five to forty percent of that overhead is reducible with AI tooling that is already public. You already own the licences. The question is whether your delivery process reflects it yet. And if you want a public proof point. Fellowmind built Hive AI, an agentic platform whose flagship agent matches consultant CVs to RFP requirements. Built by a consultancy, productised for consultancies. That is the customer-zero pattern this session is about, spot the friction in your own delivery, build the agent, and the agent becomes part of what you sell.

DO: Walk the five phases left to right. Pause on Pursue and Scope, the two highlighted at the front. Land hard on the hint underneath. Then mention the loop: Run feeds back into the next Pursue when the customer comes back for the next thing.

SAY: Every CAIP engagement follows the same five-phase arc. Pursue is the front-of-funnel work: account research, proposals, architecture sketches, estimates. Scope is the workshop, requirements, ADRs, reference design. Build is code, tests, pull requests. Ship is release and deploy. Run is operate, monitor, learn, capture. Most of the noise about AI in delivery focuses on Build. That misses where the money is. Sixty to seventy percent of every project's consultancy overhead sits in Pursue and Scope, the client-facing front of the arc. Workshops, requirements, architecture assessments, proposals. That is where AI-first delivery compounds first. The next slides show you the specific tools that bite into that overhead.

DO: This is the model slide. Don't read every cell, let the audience scan. Walk the rows top to bottom. Pause on Build (most density) and Run (where Continuous AI lives). Land on the right column, every phase has a human gate.

SAY: This is where I want you to stop seeing Frontier as a tool catalog and start seeing it as a delivery model. Five phases, five columns. Each row has a lead role, the AI assets they pull on, the artefact that hands off to the next phase, and the human gate that signs it off. The shape is what your customers' CIOs are buying. The tools fill the cells, and the cells will change every six months. The shape stays the same.

DO: Section transition. Hand gesture across the lifecycle slide you just showed.

SAY: Let's take that lifecycle and map the tooling. Three views coming up. Client-facing work, where partners lead. Delivery execution, where speed compounds. And the project management backbone that ties it together.

DO: Two cards. Take them one at a time. Don't read them verbatim, elaborate.

SAY: Pursue first. The front-of-funnel work: account research, proposals, architecture sketches, estimates. M365 Copilot drafts the proposal content. Azure Copilot pulls reference architectures and cost models from the Architecture Center. Copilot Studio is where partners are starting to build their own pre-sales agents. Fellowmind built Hive AI: an agentic platform whose flagship agent matches consultant CVs to RFP requirements, already in production. That is the customer-zero pattern. Pre-sales stops being a blank page. Then Scope. Workshops, requirements, ADRs, reference design. M365 Copilot does the recaps and tracks action items. WorkIQ gives you workplace analytics so you walk into the workshop already knowing how the customer's teams actually work. Copilot Studio prototypes the agent live in the workshop, demoed back to the customer the same week. Foundry templates and the Architecture Center cut the design loop from two weeks to four days.

DO: Three phases, three cards. Emphasise agent mode on the Build card; that is the 2026 shift. Land on the Cowork strip at the bottom. That is the always-on layer most partners haven't seen yet.

SAY: A year ago we called GitHub Copilot an autocomplete tool. That framing is dead. Build phase. GitHub Spec Kit turns workshop output into structured plans the agent can execute against, the bridge from SOW to working code. Then agent mode drafts the code, runs the tests, reads the errors, opens a pull request for review. Azure MCP gives it live cloud context, so it knows what is actually deployed in your subscriptions. ADO MCP keeps work-tracking honest. Same developer, materially more throughput on routine build tasks: boilerplate, tests, infra scaffolding. Senior judgment stays at code review and architecture decisions. The agent stops being the bottleneck for everything around them. Ship phase. GitHub Actions with Copilot assist. IaC for environment parity. Deployment drift caught before it reaches production. Change advisory and the deploy gate stay human. Run phase. Azure Copilot for monitoring. Incidents summarised, root causes proposed, runbooks generated on the fly. Continuous AI workflows keep docs fresh and triage issues without a person in the loop. Eval thresholds catch model drift before customers do. And alongside all of it, GitHub Copilot Cowork handles the repeating admin work that doesn't belong on a consultant's desk: status roll-ups, ticket triage, documentation nudges, recurring reports. Speed compounds because every phase hands cleaner context to the next, and the boring work doesn't sit on a consultant's desk any more.

DO: Spend extra seconds on the catalog block. This is the piece most partners still do not know exists.

SAY: This is the piece that ties it together. What changed this year matters. Microsoft now publishes an official MCP catalog at github.com/microsoft/mcp. Azure MCP, ADO MCP, Fabric MCP, Microsoft Learn MCP, SQL, Power BI, Clarity, Data Factory. One place, one naming convention, remote endpoints where it makes sense. If you were waiting for MCP to feel official before putting it in production, that wait is over.

DO: Take a breath. Switch to terminal. Check the projector is still on the right monitor. Read the pre-flight footer aloud, that's your 30-second governance beat before going live.

SAY: Enough slides. Let me show you. Quick pre-flight before I run anything live: this runs under managed identity with scoped access. Every call is audited. There are human review gates on anything that reaches production. The trust boundary is wrapped around what you're about to see, the full breakdown is at the end. Now, the demo.

DO: Pre-demo question, ask the room: 'if I gave this to a consultant, how long? An hour? Half a day?' Get two or three answers. THEN make the transcript drop the move they remember, open the CLI, drag the recap file in, and only then type the prompt. That visible 'I'm grounding the agent in real customer context' moment is what Henri flagged as the differentiator. When the PR step appears, pause and call it out: 'this is what catches the agent if it gets it wrong, security scan, policy lint, codeowner review run before any human reads the code.' That answers the 'devs just become PR reviewers' worry head-on (Juan Manuel #1). The seven stations on the trail are the demo beats: 1) Transcript drop (visible grounding), 2) Prompt, 3) Azure MCP query, 4) Bicep generation, 5) PR + CI gates (the safety beat, pause here), 6) ADO work item, 7) Handoff summary.

SAY: I need to set up a landing zone for a new customer project. Old world, two to four hours. Most of that time isn't typing, it's the consultant rereading a meeting transcript trying to remember what the customer asked for. Watch what happens when I just hand the transcript to the agent. One prompt. Customer recap goes in, the agent reads what the customer actually said, calls Azure MCP to check what's already deployed in the subscription, drafts Bicep review-ready against your patterns, opens a PR that triggers your CI checks (security scan, codeowners) before any human reads the code, logs the ADO work item, and drafts the handoff summary. None of that ships without a senior pair of eyes. The senior is reviewing the work the gates already validated, instead of typing. The real point is grounding. The agent reads actual customer words instead of a prompt I cooked up. FALLBACK: if the live demo fails, cut to the pre-recorded terminal capture and narrate over it. Transcript source in real engagements: Teams transcription, M365 Copilot meeting recap, or pasted notes.

DO: Section transition. Quick.

SAY: Now the delivery paths. These are the shapes an engagement can take. Pick the one that matches where your customer actually is.

DO: Read the four names out loud. Don't explain yet, the next four slides are dedicated to each.

SAY: Four paths. Workshop-to-Plan is the universal starter. I'd bet every engagement in this room starts with some version of a workshop. Agentic Modernization is for app and data migration, which is where most CAIP pipeline lives. AI Path to Production is the meta-play, you're using AI tools to deliver AI projects, and your customer is doing the same. And AI-First Delivery is the GitHub Copilot-led path across the full SDLC. We'll take each one in turn.

DO: This is the path partners can run THIS WEEK. Emphasise the zero-barrier framing.

SAY: Workshop-to-Plan is the path every partner in this room can start on Monday. Six steps. The punchline is on the right, a traditional cycle eats fifteen to twenty-five hours of consultant time across prep, workshop, and write-up. With this stack, four to six. That's not a projection. Partners doing this today hit those numbers on their second or third run.

DO: Walk the five steps. Slow down on Execute, that's where the biggest speedup lives.

SAY: Agentic Modernization is the second path. Discover. Azure Migrate with AI-powered assessment auto-classifies workloads instead of a two-week manual inventory. Plan. AI drafts the TCO model, Azure Copilot gives architecture guidance for target state. Execute is the heavy lifter. GitHub Copilot does the refactoring. Modernize Copilot handles framework upgrades. Cloud Accelerate Factory is there when you need Microsoft engineering in the room. Validate and Operate close the loop. The whole path is partner-led. Microsoft backs you on the hard parts.

DO: Flag the rebrand explicitly, this is the single biggest naming change this year. Most customers haven't caught up.

SAY: AI Path to Production is the meta-play. Your customer wants to ship an AI product. You ship it using the same AI tools you're teaching them. Four stages. Readiness, Foundations, Build, Govern. The naming update you need to know. Azure AI Foundry became Microsoft Foundry late last year. Foundry Agent Service is the primitive you will spend the most time in. Prompt agents are generally available. Workflow agents and hosted agents are in public preview, which is the right time to start building pilots. Agent manifests, agent identity, on-behalf-of authentication, built-in MCP support, this is the production substrate.

DO: Use this slide to push back if anyone reduces this path to 'just MCP'. Walk all four cards. Pause on Continuous AI, that's the surface most partners haven't seen yet.

SAY: AI-First Delivery is GitHub Copilot adopted across the full SDLC. A team capability. The laptop-autocomplete framing of 2024 is gone. Four surfaces around it. MCP is the connector, the Microsoft catalog plus your own custom servers. Yes, some partner IP lives there. But not all of it. Your methodology lives in skills and prompt libraries. Your quality bar lives in eval suites, automated tests that catch regressions before deploy. And the surface most partners haven't seen yet. GitHub's Continuous AI: repo-level agents that keep docs fresh, triage issues, run fault analysis, and lift quality on every PR. Partner IP compounds across all four.

DO: Slow down. This is the signature visual of the deck. Let the audience read the grid for five seconds before you narrate. Point at one role that matches your own consulting focus. Stress that the descriptions are written deliberately as 'what is different on Monday', not what the role does in general.

SAY: This is the slide I want you to photograph. Six roles every CAIP partner already has. Six agent patterns, one per role. Each card answers a single question: what is this person doing on Monday that they were not doing on Friday? The Solution Architect is drafting reference designs in hours, not days, against your live Azure inventory. Account Leads walk into the customer call with a proposal first draft and the past wins already surfaced. For the Delivery Manager, the Monday status report is written for her, she reviews and forwards. Tech Leads review pull requests with full repo context, and the agent is the scribe in the design review. Your AI Engineer is generating evaluation harnesses from the spec, with prompt versioning living in CI. The Data Engineer has pipeline drafts and RAG indexes ready for review before the standup. Every one of these is buildable on the public Microsoft stack, two to four weeks of partner engineering each. And the foundation just got cheaper: Microsoft shipped the Azure Skills Plugin a few weeks ago, twenty-five Azure skills, two hundred MCP tools, one command. That gives every delivery team the starter toolbox. Your two to four weeks is layering your IP on top, your plays, your ratecards, your customer context. The partners who build the first two or three are going to be very hard to out-pitch in twelve months.

DO: Direct eye contact with the group. Ask implicitly, which tier are YOU? Read the metric line under each card last, that's the answer to 'how do I prove this to my CFO?' (Jarrod #17).

SAY: Concrete actions, by tier, and the numbers each tier should be measuring. Just Starting: turn on Teams transcription, get M365 Copilot in front of your delivery team, start a GitHub Copilot trial and install the Azure Skills Plugin, one command and your delivery team has twenty-five Azure skills and two hundred MCP tools, today. Run one Workshop-to-Plan this month. Measure adoption, % meetings transcribed, weekly active Copilot users, workshop hours per engagement. If those numbers don't move, nothing else will. Have the Basics: ship your first AI-first engagement on the public Microsoft stack. Measure flow, time-to-first-PR, rework rate on AI-drafted artefacts, documentation freshness. These are the metrics your delivery managers can act on. Ready to Scale: your IP becomes MCP servers, your methodology becomes prompt libraries, and the numbers go to the CFO. Some partners call this the CoE: standards, repeatable assets, KPIs. Gross margin per engagement, billable utilisation, defect escape rate. If you can publish those quarter on quarter, you're not selling AI delivery, you're proving it.

DO: Pause after reading the heading. Let the blocks speak for five seconds. Then pick one, 'Read a docs URL' is my favourite, and narrate why that is the real unlock. No engineer needed to translate docs into config.

SAY: What you are about to feel in three minutes is this. You paste one prompt. Copilot CLI does four things in a row that, yesterday, would have been your job. It picks where to put code. Reads the documentation. Edits the configuration. Reboots its own tool chain. None of this needs a preview waitlist. It is the pattern. Every exercise your consultants do for the next year starts to look like this. That is the bet.

DO: Hand out the repo URL. Read the scenario line out loud. Do not walk them through the setup, it is in the README. Walk the room while they work.

SAY: Twenty minutes. You are the solution architect. Nordwind Aerospace just handed you a brief they need for their board in ten days. Open the exercise README. Read the meeting notes. Then prompt Copilot to install the Microsoft Learn MCP, that is the move I want you to feel. After that, draft the brief. Grounded. Specific. Cited. Every instruction you need is in the README. I'm walking the room. Go.

DO: Final slide. Slow right down. Land on the footer. Then thank the room and open for questions.

SAY: Last slide. I moved this one out of the appendix because if I skipped over it, you would rightly stop me. Everything you saw today sits inside Microsoft's enterprise trust boundary. Your customer's data does not leave it. No model trains on it. Entra handles identity. Foundry handles content filtering and evaluation. The six Responsible AI principles are built into the platform from day one. And on the agent itself, tool allowlists scope what each one can touch, approval gates fire on every write action, every action is logged, every change is reversible. The rails are what let the agent move fast safely. That is why an AI-first partner delivery practice is defensible. It is also why your customer's CISO will let you ship. Thank you. Let's talk.

APPENDIX. Press D anywhere in the deck to jump here, B to return.

DO: Hidden by default. Press D from anywhere to jump here, B to return to where you came from. Pull this out only if devs/dev-leads are in the room. The video is pre-recorded, let it play, do not narrate over it. (Juan Manuel #2)

SAY: This is the leap. Up to here we've been talking about Copilot speeding up your devs. This slide is what happens when you stop using Copilot as one helper and start orchestrating a team of agents. Squad. Brady Gaster's open-source multi-agent orchestrator, defines a team in TypeScript that lives in your repo. Specialist roles fan out in parallel. File-write guards and approval gates baked in. Persistent memory across sessions. One install, one squad init, and you direct the team. Watch the demo, then we'll talk about what changes when your delivery model is a squad of agents instead of a single Copilot session.