Tag: Interactive Slides

The verdict: PowerPoint can now host a small interactive experience inside a slide.

My first deck showed that Create interactive slides can produce polished explainers. The second pushed the same feature into quizzes, timed simulations, design tools, and an architecture workshop.

That is a much bigger idea than “make this slide more interactive.”

I used no VBA and did not hand-code a PowerPoint add-in. Copilot generated and embedded each experience.

The useful question is what kind of interactive experience belongs inside a presentation.

Table of contents

• What Microsoft actually announced
• Two decks and a deliberate escalation
• Download the two PowerPoint decks
• 1. An AI shortcut story becomes clickable
• 2. Four Models turns a comparison into a constellation
• 3. Work IQ becomes an information explorer
• 4. One Copilot becomes a selectable hub
• 5. Three Harnesses makes three options easy to compare
• 6. Agent Arena turns review material into a challenge
• 7. Agent Launch Control responds to risk choices
• 8. Agent Incident adds time and consequences
• 9. The Dataverse ERD Builder makes data modelling interactive
• 10. The Microsoft Architecture Builder turns the slide into a canvas
• 11. Agent Architect is the strongest example
• The prompts behind the slides
• What is actually inside the PowerPoint files
• The limitations matter
• How to try Create interactive slides
• Final verdict
• Sources

What Microsoft actually announced

The feature belongs to Microsoft’s Copilot in PowerPoint.

Microsoft announced Create interactive slides in PowerPoint with Copilot skill (Windows and Mac) in Message Center item MC1461152. The August 28, 2026 notice described a worldwide preview in the Microsoft Copilot Frontier program. It listed Windows desktop as available and Mac as rolling out, with completion expected in early September. The notice did not give a general-availability date, and I could not find a newer public Microsoft update confirming completion of the Mac rollout as of September 8.

Microsoft describes PowerPoint skills as reusable capabilities for repeatable tasks. Open Copilot, select the + menu, choose Choose skills, and select a skill. You can also invoke one with an @mention. In my build, this skill appeared as @create-interactive-slides.

Frontier matters here. Microsoft says Frontier features are preview and subject to change. Frontier is controlled at the tenant level: an admin can enable it for all users or selected users, and users without a Microsoft Copilot license are not shown Frontier features.

Two decks and a deliberate escalation

Version 1 contains six interactive explainers. It gave me a strong baseline: could Copilot make information easier to explore without turning the presentation into a mess?

Version 2 pushed the same idea toward software. Could a slide track state, score decisions, run a timer, build a data model, or help a room assemble an architecture?

The examples below are ordered by how far they stretch the idea of a slide. They start with focused explainers and finish with the prototype I would most want to use in a real workshop.

Download the two PowerPoint decks

Want the receipts? Download the original PowerPoint files and test the interactions yourself.

Interactive playback depends on your PowerPoint build and environment. Unsupported viewers may show the static fallback instead.

1. An AI shortcut story becomes clickable

The first V1 slide tells a five-step story about an AI model finding an unintended shortcut through a broken evaluation environment.

Each selection changes the main explanation, highlights the current step, and updates the progress bar. The intended path and the path actually taken remain visible, so the audience can inspect the difference without jumping between slides.

This is the most natural starting point for interactive slides. It replaces a click-by-click animation sequence with a visual the presenter can explore in any order.

2. Four Models turns a comparison into a constellation

The Four Models slide swaps a comparison table for a selectable constellation. Choosing a model updates its role, description, and supporting cards, and highlights it in the visual.

The interaction keeps all four options visible while giving the selected model room to explain itself. It avoids cramming every detail onto the screen at once.

3. Work IQ becomes an information explorer

My Work IQ slide adds a richer interaction model. It has signal controls for email, meetings, chats, files, people, and business systems, plus separate controls for data, memory, and inference.

Hovering previews a topic. Clicking pins it. Clicking again returns to the overview. The full system stays visible while the detail panel changes.

This feels less like revealing bullet points and more like inspecting a system.

4. One Copilot becomes a selectable hub

My One Copilot slide places Chat, Cowork, Code, and Autopilots around a concept labelled “Super App.”

Hovering previews an experience. Clicking pins it and changes the explanation while the hub remains visible. The same interaction can explain individual parts without losing the larger product story.

5. Three Harnesses makes three options easy to compare

My final V1 example compares three sample harness options labelled Standard, GitHub Copilot, and Copilot Chat.

Selecting a harness changes the behaviour and billing assumptions. The other options remain visible, so the presenter can move across the comparison in the order the conversation demands.

The five V1 examples show the feature’s most obvious strength: keeping the full picture visible while the presenter reveals or compares details.

6. Agent Arena turns review material into a challenge

Version 2 starts moving beyond explainers.

Agent Arena is a six-question governance challenge. The viewer selects an answer, receives immediate feedback, and advances while the slide tracks the score.

That small change matters: the slide now responds to an answer instead of simply revealing information. It can support training, knowledge checks, and audience participation.

7. Agent Launch Control responds to risk choices

Agent Launch Control asks the audience to choose data sensitivity, action authority, autonomy, and identity for a fictional agent.

Those choices update the architecture path, readiness score, and required controls. A deliberately dangerous combination can force the scenario into a blocked state regardless of the score.

The room can change a decision together and see the consequence immediately.

Instead of explaining governance for ten minutes, I can ask the group to choose the risk factors. That turns an abstract discussion into something everyone can see and challenge.

8. Agent Incident adds time and consequences

Agent Incident introduces a timer, evidence review, containment choices, remediation, recovery, and a replay loop.

The timer changes the feel of the exercise. The audience must decide while the scenario continues to change.

It starts to feel like a lightweight tabletop exercise inside PowerPoint.

9. The Dataverse ERD Builder makes data modelling interactive

The Dataverse ERD Builder lets the viewer assemble a sample data model and explore relationship choices.

The prototype can show a native many-to-many relationship, flag the tradeoff, and then illustrate an explicit junction-table design. It keeps the tables, relationships, and explanation together.

This does not replace the real Dataverse designer. It gives a workshop group a quick way to make the reasoning visible before implementation begins.

10. The Microsoft Architecture Builder turns the slide into a canvas

The Microsoft Architecture Builder adds components, connectors, boundaries, notes, an inspector, review advisories, and a flow demonstration.

At this point, the slide has become a small design surface. The audience can assemble an architecture, inspect the path, and discuss what is missing while staying inside the presentation.

11. Agent Architect is the strongest example

Agent Architect is the prototype I would actually take into a solution design workshop.

It provides a component palette and separate areas for the experience, agent, data, actions, and governance. The audience can place Microsoft 365, Copilot Studio, Dataverse, Power Automate, identity, approval, monitoring, and deployment controls into the design.

The review panel changes as the audience adds components. Missing dependencies and risky choices surface immediately. The completed design can then run through a simulated refund scenario and produce an execution summary.

This is the best demonstration of what the feature could become.

A static architecture tells people what someone already decided. An interactive architecture lets the room test the reasoning behind it. It can expose assumptions while the people responsible for the decision are still together.

The prompts behind the slides

I used ChatGPT in a separate conversation to turn my ideas into detailed briefs, then used those briefs with Create interactive slides. I recovered the source briefs for the V2 examples from that conversation. The original V1 requests were not in the files I reviewed, so those five prompts are faithful reconstructions based on the finished slides.

The PowerPoint files preserve the interactive experiences, but not their prompt history. I have labelled the reconstructed prompts and abridged the recovered source briefs for readability.

V1: reconstructed prompts

AI Shortcut

Create one full-slide interactive explainer for a technical audience about an AI model exploiting an unintended shortcut in a broken evaluation environment. Keep the intended route and the route actually taken visible. Add five selectable stages that can be opened in any order. Each selection should update the explanation, highlight the active stage, and update the progress indicator. Clearly label the scenario as illustrative.

Four Models

Create one full-slide interactive comparison of four AI models. Keep all four visible in a constellation around a central detail area. When the viewer selects a model, highlight it and update its role, description, strengths, tradeoffs, and sample metrics. Let the presenter compare the models in any order without leaving the slide. Treat names and metrics as sample content.

Work IQ

Create one full-slide interactive explorer that explains Work IQ as a system. Place email, meetings, chats, files, people, and business systems around central data, memory, and inference layers. Hovering should preview a topic, clicking should pin it, and clicking the active topic again should return to the overview. Keep the whole system visible while the detail panel changes.

One Copilot

Create one full-slide interactive hub called One Copilot. Place Chat, Cowork, Code, and Autopilots around a central concept labelled “Super App.” Hovering should preview each experience. Clicking should pin it and update the explanation. Keep the whole hub visible so the presenter can move between experiences without losing the larger product story.

Three Harnesses

Create one full-slide interactive comparison of three sample Copilot Studio harness options labelled Standard, GitHub Copilot, and Copilot Chat. Keep all three visible. Selecting one should update its behaviour, billing assumptions, strengths, and tradeoffs. Let the presenter compare them in any order and clearly label the content as illustrative.

V2: abridged from the recovered source briefs

Agent Arena

Use the built-in create-interactive-slide skill to create exactly one 16:9 interactive slide titled AGENT ARENA — Would You Let This Agent Go Live? Create a polished, scenario-based Power Platform and AI governance quiz that behaves like a complete game inside one slide. Include a Start Challenge button, six sequential questions, four large answer buttons, a score, progress bar, 20-second countdown, answer feedback, one 50/50 lifeline, and a Restart Quiz control that resets every state.

Agent Launch Control

Create exactly one 16:9 interactive slide titled AGENT LAUNCH CONTROL — Is this agent ready for production? Build a fully functional enterprise-agent governance simulator. Create four independently changeable selectors for data sensitivity, action authority, autonomy, and identity. Every selection must immediately recalculate the readiness score, status, architecture, warnings, required controls, and recommendation. Apply mandatory blocked states to dangerous combinations and explain exactly what triggered them.

Agent Incident

Use the built-in create-interactive-slide skill to create exactly one 16:9 interactive experience titled AGENT INCIDENT — 7 Minutes to Containment. Create a cinematic incident-response simulation inside one slide. Let the participant investigate evidence in any order, make containment and recovery decisions, and reach an outcome based on those choices. Keep the countdown, risk, affected-record count, incident status, architecture, and timeline updated. Include a Replay Incident control that resets every variable and visual state.

Dataverse ERD Builder

Use the built-in create-interactive-slide skill to create exactly one 16:9 interactive experience titled DATAVERSE ERD BUILDER — Design Your Data Model. Build a functional, click-driven logical data-model builder inside one slide. Do not use drag-and-drop. Provide SELECT, ADD TABLE, CONNECT 1:N, CONNECT N:N, and MOVE modes. Create a 7×7 modelling grid with 49 clickable cells, compact table cards, relationship controls, an inspector, and a persistent Cancel Current Action control.

Microsoft Architecture Builder

Use the built-in create-interactive-slide skill to create exactly one 16:9 interactive experience titled MICROSOFT ARCHITECTURE BUILDER — Map the solution. Show the flow. Create a functional click-driven architecture-diagram builder inside one slide. Do not use drag-and-drop. Provide SELECT, ADD COMPONENT, CONNECT, ADD BOUNDARY, MOVE, and ADD NOTE modes. Use a 7×7 grid, a compact component palette, clean routed connectors, an inspector, review advisories, and a Presentation Mode that hides the editing interface.

Agent Architect — original brief and repair prompt

Use the built-in create-interactive-slide skill to create exactly one 16:9 interactive experience titled AGENT ARCHITECT — Build It. Govern It. Run It. Create a functional enterprise-agent architecture builder that behaves like a lightweight application inside one PowerPoint slide. Include a component palette, architecture zones, a live review, dependency validation, readiness scoring, three refund scenarios, simulated execution, and Undo, Clear Canvas, Reset Challenge, and Architecture X-Ray controls.

The first build made drag-and-drop look available, but it did not work reliably. The follow-up brief changed the interaction model:

Edit the existing Agent Architect interactive slide. Preserve all functioning scoring, scenario testing, warnings, X-Ray views, Undo, Clear Canvas, and Reset logic. Remove every drag-and-drop instruction and interaction. The participant should click a component, see compatible slots highlighted, click a slot to place it, use the X to remove it, and select an occupied slot to replace it. Rebuild the architecture as a clear left-to-right execution flow and use straight lines or clean 90-degree elbow connectors.

That iteration is the most useful prompting lesson in the whole test: describe the experience, what the audience can change, what must stay visible, and what consequence should follow. When an interaction fails, repair the interaction model instead of only restyling the slide.

What is actually inside the PowerPoint files

I inspected both .pptx packages after generating them.

Version 1 has six slides. Version 2 has eight. Every slide contains one full-slide object named Copilot Content Block. Each block stores self-contained HTML, CSS, and JavaScript, plus a PNG snapshot fallback.

I found no VBA project, ActiveX control, native PowerPoint trigger, or external webpage referenced by the interactions.

That explains both the power and the tradeoff.

Traditional PowerPoint slide	Interactive content block
Built from native shapes, text boxes, and charts	Stored as one full-slide content block with HTML, CSS, and JavaScript
Edited object by object	Appears as one content block rather than separately selectable objects
Uses PowerPoint animations and triggers	Can use clicks, hover states, timers, drag and drop, and keyboard input
Static export reflects the current slide objects	Static export uses a stored PNG fallback

The exact implementation could change during preview. This is what my two test files contained on September 7, 2026.

The limitations matter

The preview status is not a footnote. It changes how I would use this feature today.

The content is not a normal collection of editable shapes. PowerPoint sees one content block. I cannot select an internal button and edit it as an ordinary PowerPoint shape.

Static output loses the interaction. My PowerPoint PNG exports used the stored fallback image. In a few V1 slides, that fallback preserved a different selected state from the live startup state.

Compatibility is still an open question. I tested the generated content and inspected the PowerPoint packages. I have not validated recipient playback in PowerPoint for the web, on iPad or Mac, offline, or during coauthoring.

Accessibility needs deliberate review. A clickable visual can still miss keyboard navigation, visible focus, screen-reader support, contrast, or motion requirements. Interactive does not automatically mean accessible.

The logic can look authoritative even when it is illustrative. If a slide calculates risk, gives a score, or recommends controls, label the method and validate it. A polished simulator can make weak logic look official.

AI-generated content needs a human fact check. Microsoft recommends reviewing and verifying Copilot output before using it in a presentation.

My practical rule: keep a static fallback, record a short demo, test on the exact machine that will present it, and never let the visual polish outrun the evidence.

How to try Create interactive slides

If your admin has enabled Frontier for your account and the skill appears in your PowerPoint build:

1. Open Copilot in PowerPoint.
2. Select the + menu in the prompt field, then choose Choose skills.
3. Select Create interactive slides, or invoke it with the @create-interactive-slides mention if it appears in your PowerPoint build.
4. Describe the subject, the audience action, the states or consequences, and what should remain visible while the audience interacts.
5. Test every control in the intended presentation environment.

I did not find a Microsoft-published prompt for examples this advanced. The reconstructed prompts above show the most reliable pattern I found: specify the behaviour, state, and consequence instead of only describing a layout.

Final verdict

Create interactive slides is the most interesting PowerPoint experiment I have seen in years.

V1 made information explorable. V2 made the presentation respond to decisions. Agent Architect turned the slide into a workshop tool.

The preview still needs stronger documentation, compatibility testing, accessible interaction patterns, and a clearer editing story. But the foundation is already here: PowerPoint can host a generated, stateful experience instead of only describing one.

The best result was not the one with the most motion. It was the one that made a complicated architecture easier to build, question, and understand together.

Enough slides. Let’s see it work.

Sources

• Microsoft 365 Message Center: MC1461152 — official, tenant sign-in required
• Public archive of MC1461152 — mirrors the Message Center text; not operated by Microsoft
• Use custom skills with Copilot in PowerPoint
• Get started with the Microsoft Copilot Frontier Program
• Edit with Copilot in PowerPoint