What's New in Microsoft EDU webinars - October 2026
Join the Microsoft Education Product team on Wednesday, October 28 at 8am Pacific Time or 4pm Pacific time for a webinar exploring the latest updates in Microsoft Education! Discover new tools and exciting features designed to save educators time, personalize learning, and boost student engagement. We'll share demos, practical tips, and ways to get started with these powerful tools. You'll also have time to ask the team any questions that are top of mind. Agenda: ✅ Teach module in Copilot ✅ Study & Learn agent ✅ Microsoft Learning Zone ✅ Copilot Notebooks ✅ Teams for EDU ✅ OneNote Class Notebook ✅ Learning Activities Register for Wednesday, October 28th at 8am Pacific time: https://aka.ms/WNIEDUOct28Option1 Register for Wednesday, October 28th at 4pm Pacific time: https://aka.ms/WNIEDUOct28Option2 Whether you're an educator, school leader, or IT professional, come discover what's new and what's possible with Microsoft EDU! Mike Tholfsen Group Product Manager Microsoft EducationStudy and Learn Agent: Now in 48 Languages, images improvements, ready when you open Copilot
When we brought Study and Learn Agent to general availability, the promise was simple: the student does the thinking. Study and Learn asks before it tells. It pushes you to try. It makes learning interactive and quizzes you on what you missed. It lives at aka.ms/studyandlearn inside your Microsoft Education tenant. It coaches learners across any subject; explaining concepts, walking through problems step by step, supporting writing without doing the writing, and generating flashcards, quizzes, matching, and fill-in-the-blank activities from a learner's own materials. The design principle underneath all of it: preserve the productive effort that makes learning stick. The learner does the thinking. The agent coaches the thinking. 👥 Who can use it Study and Learn is available and pinned by default for every adult learner in a Microsoft Education tenant. No setup required — it's right there in the left navigation of Microsoft 365 Copilot. For K-12 students aged 13–17, there's one step first: Copilot Chat has to be enabled. Until it is, students in your tenant can't reach the agent. The good news is that it's a simple set of steps tutorial shows the exact enablement steps for IT admins. Watch the enablement walkthrough. 🎥 Full video tutorial If you want the full tour, Mike Tholfsen made an end-to-end tutorial that walks through every feature, start to finish. It's the fastest way to see the agent in action: Watch it here: ✨ Copilot Chat now opens with Study and Learn pre-selected For K-12 students who already have Copilot Chat enabled, Study and Learn is now pre-selected the moment they open Copilot Chat. The coach is right there, ready - no hunting through a menu, no wondering which agent to pick. Copilot Chat opens by default in the learning mode. A student who wants to work with something else can dismiss it in a tap. IT admins stay in control. The setting lives in the Education settings panel in the Microsoft 365 admin center. It's ON by default for K-12 and OFF by default for higher education, where admins can turn it on when they're ready. 🌍 Now available in 48 languages At GA, Study and Learn was optimized for English (US). Now it speaks the way your learners do. The agent is available in 48 languages beyond English. Set your browser or operating system to a supported locale and visit aka.ms/studyandlearn. The user experience and conversation are set in your language. The learning activities - flashcards, quizzes, matching, fill-in-the-blank - appear in your chosen app language. Additional language support is rolling out now and will be available to all users in the coming days. And you're not locked in. A learner can switch languages mid-conversation for a genuinely multilingual study session. Learning a new language and want the vocabulary words in the new language but the explanations in your native language? No problem. Want to switch languages to practice the vocabulary with Study and Learn, no problem, you can do that too. The coaching language follows you. For a student learning in their second language, or a family where the kitchen-table language isn't the classroom language this is the difference between a tool that talks at them and one that meets them where they are. 🖼️ Images that show, instead of just tell Some things are easier to see than to describe. A cell's structure. The layers of the atmosphere. Where the femur meets the hip. Study and Learn conversations can now include a carousel of relevant, web-safe images sourced through search, woven right into the flow of the agent's response. Each image supports the next step in a learner's understanding, a visual nudge toward the answer they're working out for themselves, without shortcutting the effort that gets them there. This is especially powerful for visual subjects like biology, geography, and chemistry, where a single well-placed image does what a paragraph can't. This experience will get better over time. It is rolling out now and will be available to all users in the coming days. You can always share feedback here. 💬 A prompt pack to help learners get started Here’s a prompt pack - a set of ready-to-use prompts that show learners exactly how to put the agent to work, organized around the moments they actually face: Understand a difficult topic — “Use these materials to find the most important ideas and help me understand them.”, “Explain [topic] step by step, then check my understanding.” Practice what you know — “Create a matching activity for the key terms in this chapter.”, “Make a fill-in-the-blanks activity from these materials.” Improve my work — “Review what I missed and explain the ideas I need to practice.”, “Help me understand why my answer was incorrect, then let me try again Work on an assignment — “Help me brainstorm ideas for this assignment.”, “Review my draft and help me find one area to strengthen.”, “Help me check whether my evidence supports my main point.” Get ready for a test — “Use these materials to identify the topics I should focus on.”, “Give me a five-minute review of these concepts I’m still struggling with.” Every prompt keeps the learner in the driver's seat — the agent helps them think and practice, never hands over the answer. Share the pack at the start of a unit and watch how it changes the way students engage. 📋 Coming soon: educators can assign the agent from Teams Everything so far puts the coach in the learner's hands. This next one puts it in the educator's. Rolling out soon, educators will be able to assign the use of Study and Learn Agent directly from a Teams assignment. Instead of a blanket "you can use this," you'll be able to point learners to the agent for a specific assignment built right into the assignment they're already opening. The through-line Every one of these (the languages, the pre-select, the prompt pack, the images, the assignments) meet the learner where they are. In their language. The moment they open Copilot. With the words to get started and the visuals to see it clearly. Pointed there, when it counts, by the educator who knows them. Open Microsoft 365 Copilot. Look in the left navigation. Then watch Mike's full tutorial and try it on the thing you're studying next. Educators can also access the full professional development course on Study and Learn complete with suggestions on introducing the agent to students. Try Study and Learn Agent · Microsoft Education license required. K-12 student access (ages 13–17) requires IT to enable Copilot Chat. Resources: Try Study and Learn in your tenant: https://aka.ms/studyandlearn Full tutorial on Study and Learn: https://aka.ms/studyandlearnvideo Professional development for educators: https://aka.ms/studyandlearnmodule Enable Copilot Chat: https://aka.ms/enablecopilotchatvideo Support documentation: https://aka.ms/studyandlearndocumentation Anoo Padte is Principal Product Manager for AI in Education at Microsoft.Hands-on Webinar: Copilot Notebooks and Microsoft Learning Zone
Join us on Wednesday, October 21 @ 8am Pacific Time for a practical, educator-focused webinar exploring Copilot Notebooks, Study Guide, and Microsoft Learning Zone. Discover ways to bring AI into everyday teaching and learning, from working with classroom materials to supporting independent student learning and active participation in the classroom. We’ll walk through classroom scenarios, demonstrate key features, and share ideas you can adapt for your students. Whether you’re getting started with AI or looking for new ways to use it, this session will help you connect these tools to real classroom needs. What we’ll cover: Copilot Notebooks: Explore ways to work with your teaching and learning materials. This includes the Study Guide embedded in Copilot Notebooks to support student review and independent learning. Microsoft Learning Zone: Learn how to turn any teaching idea into an interactive lesson in minutes, then share it with students for self-paced learning or use it to facilitate active participation in the classroom. Register here: https://msit.events.teams.microsoft.com/event/msit.b38c4730-d9e5-49ba-aa00-4cbaefce36bc@72f988bf-86f1-41af-91ab-2d7cd011db47 We look forward to seeing you at the webinar! Mike Tholfsen Group Product Manager Microsoft EducationFour opportunities for IT admins to get ready with Copilot Chat for education
Microsoft Education is offering four live webinar opportunities for IT administrators who want to confidently deploy and manage Microsoft 365 Copilot Chat. Each session covers the same practical guidance, so you can select the date that best fits your schedule. What you’ll learn We’ll walk through Copilot Chat configuration from the tenant level to the end-user experience, including options for students ages 13+, CSV, SDS, and PowerShell uploads, agents and extensibility, and current licensing and security controls. You’ll leave with actionable guidance to help deploy, manage, and optimize Copilot Chat safely across your organization. We’ll also share a brief look at some Microsoft Education experiences including Teach in Copilot, the Study and Learn agent, Copilot Notebooks, and Learning Activities. Choose a session and register September 16th, Wed @ 8am Pacific time - Register for the September 16 session September 30th, Wed @ 8am Pacific time - Register for the September 30 session October 14th, Wed @ 8am Pacific time - Register for the October 14 session October 28 th , Wed @ 8am Pacific time - Register for the October 28 session Reserve your spot today. Pick the session that works best for you and join us to build a secure, manageable path to Copilot Chat adoption in your education environment. Mike Tholfsen Group Product Manager Microsoft EducationWhat's New in Microsoft EDU - Back to School 2026 webinar
Get ready for back to school (Northern Hemisphere) with the latest product updates from Microsoft Education. In this webinar, we’ll showcase new AI-powered tools, teaching resources, and product updates designed to help educators save time, personalize learning, and support every student. You’ll see what’s new across Microsoft 365 Copilot, Teams for Education, OneNote, and more, including: ✅ Teach module in Microsoft 365 Copilot ✅ Copilot Notebooks ✅ Study and Learn agent ✅ Learning Zone ✅ Teams for EDU updates ✅ The latest OneNote EDU updates And more! Join us for practical demonstrations, helpful tips, and new ideas you can put to work as you prepare for a successful school year. And don't worry if you can't make it live, we will be recorded and posting this on the Microsoft Education YouTube channel afterwards. 📅 When: Wednesday, August 26th @ 8am Pacific Time 🔗 Register here: https://df.events.teams.microsoft.com/event/df.8c4f06fc-399f-4603-8023-f5fd92601bd1@72f988bf-86f1-41af-91ab-2d7cd011db47?source=copyLinkOneEventsShareDialog Mike Tholfsen Group Product Manager Microsoft EducationCalling all IT Admins - webinar on configuring Copilot Chat and updates for Students 13+
This IT Admin-focused workshop walks through how to configure Microsoft 365 Copilot Chat, from your tenant all the way to the end-user experience. When you enable Copilot Chat for students 13+, they will also get access to the new Study & Learn agent, Copilot Notebooks, Learning Activities and more. We cover the latest features that are available — including the new 13+ student configuration options, CSV, SDS and Powershell uploads, Copilot agents & extensibility, and updated licensing & security controls. By the end, you’ll be able to confidently deploy, manage, and optimize Copilot Chat in your environment so your users can safely harness AI productivity from day one. This 45-minute webinar will be led by Bill Sluss Principal Product Manager from the Microsoft Education team. When: Wednesday, August 19th @ 8am Pacific time Register: https://df.events.teams.microsoft.com/event/df.95feda23-419a-4d99-bfad-f7e4fd52a498@72f988bf-86f1-41af-91ab-2d7cd011db47?source=copyLinkOneEventsShareDialog Mike Tholfsen Group Product Manager Microsoft EducationHands-on webinar: Set up your classroom in Teams for Education plus the new Study and Learn Agent
Join us on Wednesday, August 5th at 8:00 AM Pacific Time for a practical, 60-minute webinar to get your Microsoft Teams classroom ready for the new school year in the Northern hemisphere. Get your class set up in Assignments and Classwork, learn about new tools like Learning Activities, use Student AI Guidelines to set the right expectations for your students, and see how the Study and Learn Agent can be a study partner for your students. Follow along with your own Microsoft 365 Education account as we walk through each one. Register here: https://aka.ms/August5Training The session will be recorded and posted to the Microsoft Education YouTube channel so you can watch it later or share it with colleagues. Agenda - Get your Teams EDU classroom ready and learn about the Study and Learn Agent. ✅ Teams EDU Classwork / Assignments setup ✅ Learning Activities in Assignments and Classwork ✅ Student AI Guidelines in Teams Assignments ✅ Copilot Study and Learn Agent We look forward to seeing you on August 5th! Also, be sure to check out and sign up for our Microsoft Elevate Educator community. Mike Tholfsen Group Product Manager Microsoft EducationHands-on webinar: Teach Module in M365 Copilot and Copilot Notebooks (available for all educators)
Join us on Wednesday, July 8th @ 8am Pacific Time for an in-depth professional development webinar on the new AI-powered "Teach" module in M365 Copilot that is fully rolled out and available to everyone. We will also be covering Copilot Notebooks and the Study Guide which is now also available to all M365 Educators and Students. This will be a 60-minute hands-on webinar where the Product Management team will walk through the new updates in detail and you can follow-along at home with your own M365 Education account. To reiterate, the Teach Module and Copilot Notebooks are available globally to all educators using Microsoft 365. And don’t worry – we’ll be recording these and posting on our Microsoft Education YouTube channel so you’ll always to able to watch later or share with others. Register here: https://msit.events.teams.microsoft.com/event/msit.ed7f065d-57a5-437c-ba23-12b0ef06a259@72f988bf-86f1-41af-91ab-2d7cd011db47 Agenda: How to use the new AI-powered "Teach" module in M365. ✅ Lesson plans and the new Keep Going feature ✅ Learning Zone integration ✅ Modifying Existing content ✅ Learning Activities ✅ Coplot Notebooks plus Study Guide We look forward to having you attend the event! Also, be sure to check out and sign up for our Microsoft Elevate Educator community. Mike Tholfsen Group Product Manager Microsoft Education teamGitHub Copilot App Canvas Is a Runtime
There is a quiet shift happening in how we build software with AI. We are moving from writing static code to orchestrating living systems where developers and AI agents co-create, observe, and evolve a solution in real time. This post is a working theory of what GitHub Copilot App Canvas is actually for, grounded in a real, runnable demo you can clone today: leestott/agent-runtime-canvas. The Agent Runtime canvas open beside the chat — control bar, activity spotlight, requirement & constraints, and the live agent roster. The headline claim, which the rest of this post defends with code: Traditional UIs are for using software. Canvas is for shaping software while it runs. 1. The misconception worth getting out of the way The first instinct most engineers have when they see Canvas is to build a UI with it a dashboard, a DevOps board, an admin panel. That is the wrong mental model, and it leads to disappointment. A Kanban board rendered in Canvas is just a worse version of a tool that already exists. Canvas is not where your users live. It is where your system becomes visible to you and to the AI while you are still figuring it out. The distinction matters: You don't build Canvas instead of your UI. You use Canvas to figure out, test, and evolve the UI and the system before and during building it. Canvas solves problems your final UI should never try to solve in a visible way agent coordination, intermediate state, test validation, failure propagation. These are observability concerns, not end-user features. Canvas is intended for test validation and the implementation of agent-driven solutions not for shipping a production control panel. A useful analogy: Figma is Human-to-Human one person designs a static artifact for another person to read. Canvas is Human-to-AI-to-System a shared surface where a human, an AI agent, and a running system all act on the same live model. Figma shows you a picture of the software. Canvas is a runtime where things actually execute. 2. The positioning, stated plainly Here is the thesis the demo is built to prove: Canvas redefines software development by shifting from writing static code to orchestrating living systems, where developers and AI co-create, observe, and evolve solutions in real time. Instead of building UIs for users, we build interactive environments for agents — turning debugging, testing, and execution into a continuous, visual feedback loop that accelerates innovation and brings ideas to production faster than ever. Read that again with the demo in mind, because the demo is not a slide, it is a working Copilot CLI extension that renders exactly this loop. 3. What we built: the Agent Runtime canvas agent-runtime-canvas is a GitHub Copilot CLI canvas extension called Agent Runtime. It turns Canvas into a runtime observability and control plane for a multi-agent software system that is being designed, tested, and evolved in real time. The canvas renders a single living SystemModel that both humans and the AI agent edit at the same time. The agent drives it through five canvas actions; the human drives it through panel controls. Every change streams to the iframe over Server-Sent Events (SSE), so the system visibly evolves through interaction. The seven panels: a system you can watch think Panel What it makes observable Requirement & constraints The feature under design plus editable policies and constraints Agents Active agents, their responsibilities, and live state (idle / working / done / error / blocked) Task Flow The dependency graph of tasks across agents, with live status Artifacts The intermediate outputs each task emits Validation Test cases, pass/fail, expected vs. actual, and the reasoning behind each verdict Live State The shared memory objects the agents read and write — directly human-editable Timeline A change-over-time log, including before→after state diffs None of these are things you would put in front of an end user. All of them are things you desperately want to see while you and an AI are co-designing an agentic system. The five agent actions The AI co-creates and evolves the system by calling five actions, declared in the canvas extension: Action Effect decompose_system Break a requirement into collaborating agents + a task-flow graph execute_workflow Coordinate agents to advance tasks ( step / run / pause / resume / reset ) validate_output Run evaluation tests, return structured pass/fail + reasoning update_system_design Modify architecture/logic: requirement, constraints, agents, tasks track_state Persist/update a shared state object, recording the diff on the timeline The critical detail is that human controls and agent actions funnel through the exact same store. There is no separate "AI view" and "human view" — one model, two kinds of participant. 4. How it actually works (the parts that matter) The extension is deliberately small and dependency-free. It uses only Node's built-in modules plus github/copilot-sdk , which the CLI auto-resolves. Three files do the work: .github/extensions/agent-runtime/ extension.mjs # wiring: loopback HTTP server, SSE, /control, 5 canvas actions store.mjs # durable SystemModel + execution engine + validation ui.mjs # iframe renderer (system view, validation, state, timeline) One shared model, broadcast on every mutation The heart of the demo is the SystemStore . It is an EventEmitter : every mutation bumps a version, appends a timeline entry, persists to disk, and broadcasts a fresh snapshot to all connected panels. This is the single line that makes "humans and AI edit the same live system" true rather than aspirational: // store.mjs — every change is versioned, logged, persisted, and broadcast. _commit(eventType, summary, detail) { this.model.version += 1; this.model.updatedAt = now(); if (eventType) { this.model.timeline.unshift({ id: uid("ev"), ts: now(), type: eventType, summary, detail: detail || null, }); this.model.timeline = this.model.timeline.slice(0, 200); } this._queueSave(); // best-effort JSON persistence under ~/.copilot this.emit("change", this.model); // fan out to every SSE client return this.model; } The agent action and the human button hit the same method In extension.mjs , the canvas action handler and the iframe's /control POST both call store.execute(...) . That symmetry is the whole point — neither the human nor the AI is privileged: // extension.mjs — a human control POST maps onto the same store method // the AI agent calls through the execute_workflow canvas action. function applyControl(store, body) { switch (body.action) { case "execute": return store.execute(body.mode || "step", body); case "validate": return store.validate(body.tests); case "decompose":return store.decompose(body.requirement, body); case "inject_failure": return store.injectFailure(body.taskKey); case "edit_state": return store.editState(body.key, body.value); // ...requirement, constraints, clear_failures, update_design } } Execution you can watch one task at a time The engine advances the task graph through a visible begin→dwell→finish lifecycle so the active agent is always observable. A ready task is one whose dependencies are all done : // store.mjs — the scheduler only starts a task when its deps are satisfied. _readyTask() { return this.model.tasks.find( (t) => t.status === "pending" && t.deps.every((d) => { const dep = this.model.tasks.find((x) => x.id === d); return dep && dep.status === "done"; }), ); } When a task finishes, its agent emits an artifact and writes to shared state; when a dependency fails, the engine walks the graph to a fixpoint and marks every downstream task blocked . That is failure propagation you can see — exactly the kind of thing a production UI would (correctly) hide, and exactly the kind of thing you need exposed while designing the system. Validation as a first-class, re-runnable citizen The default evaluation suite asserts properties of the running system, not of static code — every test returns an expected value, an actual value, and a human -readable reason: // store.mjs — tests assert properties of the live system model. _defaultTests() { const t = (name, target, assertion) => ({ id: uid("test"), name, target, assertion }); return [ t("All tasks reach a terminal state", "tasks", "no_pending"), t("No tasks failed", "tasks", "none_failed"), t("Every completed task emitted an artifact", "artifacts", "artifact_per_done"), t("Design state populated before build", "state", "design_before_build"), t("Decision recorded by Reviewer", "state", "has_decision"), ]; } This is the "continuous, visual feedback loop" from the thesis, made concrete: decompose → execute → validate → redesign → re-validate, with the Timeline recording every before→after transition. 5. Run it yourself You need a GitHub Copilot CLI / app with canvas support (the canvas-renderer capability) and this repo opened as your workspace. There is no npm install the SDK is auto-resolved and the extension uses only built-in Node modules. Clone and open the workspace. git clone https://github.com/leestott/agent-runtime-canvas.git cd agent-runtime-canvas The extension auto-discovers from .github/extensions/agent-runtime/ . Open the canvas with a requirement. Ask Copilot: Open the Agent Runtime canvas with the requirement "Add CSV export to the reports page". Walk the loop. Decompose into five agents and a six-task graph, press Run ▶, watch the spotlight track the active agent, press Run tests ✓ for 5/5 green, then Inject failure ⚡ to watch downstream tasks go blocked and validation drop to 4/5 — and recover. State persists per documentId under ~/.copilot/extensions/agent-runtime/artifacts/ , so a reload resumes exactly where you left off. The companion demoscript.md in the repo gives you a tight, timed walkthrough. 6. Why this is an observability story Once you accept that Canvas is a runtime rather than a UI, the most compelling use case becomes observability of agentic systems. Agentic software is notoriously hard to debug: the interesting behavior lives in intermediate state, coordination order, and the moments where one agent's failure cascades into another's. A production UI is designed to hide all of that. A Canvas is designed to surface it, temporarily, while you are shaping the system — and then get out of the way. This reframes Canvas alongside the broader Microsoft and GitHub agent tooling story. As teams adopt the GitHub Copilot SDK and patterns like the open Model Context Protocol to wire agents into real systems, the gap is rarely "can the agent act?" it is "can a human see what the agent did, judge it, and steer it?" Canvas is a candidate answer to that second question. When you take agents toward production on Azure with services like Microsoft Foundry, the same instinct applies: build the evaluation and observability loop first, and let it shape the system before you commit a single end-user pixel. 7. The open question: why can't Canvas be multi-user? There is an obvious next frontier, and it is worth stating as an honest open question rather than a finished feature. Everything that makes Canvas valuable also makes it a natural collaborative surface: It is a shared space. It is visual. It is collaborative. Multiple participants — human and AI — interact with the same surface. If Figma earned its place by making Human-to-Human design multiplayer, the provocative question is whether a project- or repo-scoped Canvas can make Human-to-AI-to-System development multiplayer too: several engineers and several agents shaping one running system on one surface. The demo here is single-user by design, but its architecture — one shared store, versioned, broadcast to every subscriber — is already the shape you would need. That is a genuine research direction, and worth experimenting with as licensing and access broaden. 8. Honest limitations In the spirit of building credibility rather than hype: This is a demonstration. The decomposition, artifacts, and state are synthesized to make the runtime loop legible — it models an agentic system rather than running arbitrary production agents. It is single-user and single-machine. The loopback HTTP server and per-document store are local by design; multi-user is an aspiration, not a shipped capability. Access is gated. Canvas support requires a Copilot CLI/app build with the canvas-renderer capability. Licensing and preview access are the biggest practical blockers to wider experimentation today. Persistence is best-effort. State is written to a local JSON artifact; treat it as demo durability, not a database. Key takeaways Don't build a UI in Canvas. Use Canvas to shape, test, and evolve a system — and the UI — while it runs. Traditional UIs are for using software; Canvas is for shaping software while it runs. Canvas is Human-to-AI-to-System, a runtime where things execute — not a static design surface. Its strongest use case is observability and validation of agentic systems: surface the intermediate state your production UI should hide. The shared-model architecture — one versioned store broadcast to every participant — is what makes human + AI co-editing real, and what hints at a multi-user future. Next steps Clone and run the demo: github.com/leestott/agent-runtime-canvas. Read the extension source under .github/extensions/agent-runtime/ — start with store.mjs . Explore the building blocks: the GitHub Copilot SDK, the Model Context Protocol, and Microsoft Foundry for taking agentic systems toward production. Try the multi-user thought experiment: fork the store, add a second subscriber, and ask what changes when two humans and two agents share one surface.
