Hey folks! Welcome to a new year, and a new release of SQL Server Management Studio (SSMS). That’s right, we’re starting off 2026 with SSMS 22.2.1, which may look like “just another” minor release, but it’s not…it’s definitely not.
Fixes
SSMS 22.2.1 contains a set of important bug fixes, thanks to our engineers. You can find the full list of fixes in the release notes, and I’ll note that all but one are linked to an item on the feedback site. That’s my not-so-subtle way of reminding you that logging issues on the site matters 😊
As always, please search for an existing issue before you create one…and if you do find that someone else has logged the same issue/problem/error, please upvote it so we understand how many folks are affected.
We updated our roadmap when SSMS 22 became generally available, but we didn’t specifically call out that in December and January we would primarily focus on fundamentals work. In addition to some bug fixes, the engineering team is also making improvements internally, related to pipelines, testing, etc. There are a lot of behind-the-scenes improvements that will help with quality and reliability, though they may not be immediately obvious.
Features
We’ve added support for code completions in the query editor for GitHub Copilot. Thanks to those who waited patiently for this functionality! While our GitHub Copilot is based on the one for Visual Studio, we had to add database context into completions functionality. For completions to behave in the manner that you expect, we had to give the model information about the database, and make sure it provided suggestions quickly.
Code completions for GitHub Copilot in SSMS are not the same as IntelliSense, and I’d argue they exceed the concept of “IntelliSense on steroids”. The more T-SQL that exists in the editor window, the more powerful you’ll find the suggestions to be. If you find that completions and IntelliSense are competing, you may want to try turning off IntelliSense. I’m extremely pleased with the code completion capabilities, and I’m excited for you all to give it a try.
What's next?
I mentioned the SSMS Roadmap earlier, and we’ll be updating the AI experiences section to note that Agent mode is on the roadmap for GitHub Copilot. We’re also working on improvements related to instructions, which is a top request specific to AI Assistance. If that’s something you’d like to see, feel free to vote on the feedback itemand add a comment if there’s something specific in which you’re interested. Friendly reminder that votes are the quickest and easiest way for us to understand interest. It's what we check first. The comments help capture more details about what SSMS users want to see and why.
If you’re interested in other requests for GitHub Copilot in SSMS, please search the feedback site for open suggestions. I'll be adding "GHCP" to the title of all GitHub Copilot-related feedback items - both suggestions and issues - to make it easier for everyone to find. You can filter by “copilot” right now but that doesn’t quite catch everything. While Agent mode is a big space, I’d love to see more ideas about what folks want to see/do with it.
For those in the northern hemisphere, hope you’re staying warm and safe. For those in the southern hemisphere, please enjoy some sunshine for the rest of us today. Looking forward to hearing from you all about the 22.2.1 release!
This simple component can improve the user experience of your Blazor app, providing a hint of feedback that they aren’t waiting in vain.
Creating smooth experiences in Blazor applications for better interaction should always be a point to consider during their development.
One of these experiences is the feedback given to the user when processing happens behind the scenes, such as when information is being retrieved to fill a page. One of the components that can help us with this task is the Progress Telerik UI for Blazor Skeleton component, which allows you to create loader-like placeholders in the spaces where information will be. Let’s look at its features and how to integrate it into a Blazor application.
Exploring the Skeleton Component for Blazor
Let’s start by analyzing how the Skeleton component works. First of all, you need to configure the Blazor project to work with Telerik components, according to the installation guides.
The next step is to go to the page where you want to use the component, where you can add it via the TelerikSkeleton tag as shown below:
In the code above, I have added some styles to center the component on the page, resulting in the following:
Now, you should consider that the component has the following parameters that you can use to configure it:
ShapeType (enum): Allows you to select a predefined shape
AnimationType (enum): Allows you to select a predefined animation
Visible (bool): Specifies whether the component should be visible on the page or not
Width (string) and Height (string): Specify the width and height of the component
Class (string): Allows rendering a custom class in the component
From the previous properties, you can configure ShapeType with the values SkeletonShapeType.Text (by default), SkeletonShapeType.Rectangle and SkeletonShapeType.Circle, as well as AnimationType with the values SkeletonAnimationType.None, SkeletonAnimationType.Pulse (by default) and SkeletonAnimationType.Wave.
An example of the Skeleton component with these applied properties is as follows:
When visualizing the component, it looks as follows:
Although the control is quite simple to use, its power lies in combining several of these components to recreate interfaces where we want to provide feedback to the user about a loading of information, as we will see next.
Adding the Skeleton Component to a Real Case
So far we have seen the features of the Skeleton component. Now, you may be wondering how to integrate it into your application—that is, how to build an interface using several Skeleton components while data is being loaded, and then show the real data once it has been loaded.
To make this more realistic, let’s assume we have created an application using several Blazor components that simulate a social network. This is the homepage:
@page "/feed"
<divclass="feed-container"><h3class="mb-3">Feed</h3><divclass="composer card p-3 mb-4"><divclass="d-flex align-items-start gap-3"><TelerikAvatarType="AvatarType.Text"Width="48px"Height="48px"Rounded="@ThemeConstants.Avatar.Rounded.Full">HP</TelerikAvatar><divclass="flex-grow-1"><TelerikTextAreaRows="3"Placeholder="What's on your mind?"Width="100%"/><divclass="mt-2 d-flex gap-2 justify-content-end"><TelerikButtonThemeColor="primary"><TelerikSvgIconIcon="@SvgIcon.PaperPlane"></TelerikSvgIcon> Post
</TelerikButton></div></div></div></div><divclass="feed">
@foreach (var post in Posts)
{
<TelerikCardClass="mb-4"><CardHeader><divclass="d-flex align-items-center gap-3"><TelerikAvatarType="AvatarType.Text"Rounded="@ThemeConstants.Avatar.Rounded.Full"Width="48px"Height="48px">@GetInitials(post.UserName)</TelerikAvatar><divclass="flex-grow-1 w-100"><divclass="fw-semibold">@post.UserName</div><divclass="text-muted small">@post.PostedAt.ToLocalTime().ToString("g")</div></div></div></CardHeader><CardBody><pclass="mb-3">@post.Content</p>
@if (!string.IsNullOrWhiteSpace(post.ImageUrl))
{
<imgsrc="@post.ImageUrl"alt="post image"class="img-fluid rounded"/>
}
</CardBody><CardFooter><divclass="d-flex gap-2"><TelerikButtonThemeColor="primary"FillMode="Telerik.Blazor.ThemeConstants.Button.FillMode.Outline"><TelerikSvgIconIcon="@SvgIcon.Heart"></TelerikSvgIcon> Like
</TelerikButton><TelerikButtonFillMode="Telerik.Blazor.ThemeConstants.Button.FillMode.Outline"><TelerikSvgIconIcon="@SvgIcon.Comment"></TelerikSvgIcon> Comment
</TelerikButton><TelerikButtonFillMode="Telerik.Blazor.ThemeConstants.Button.FillMode.Outline"><TelerikSvgIconIcon="@SvgIcon.Share"></TelerikSvgIcon> Share
</TelerikButton></div></CardFooter></TelerikCard>
}
</div></div>
@code {
private List<Post> Posts { get; set; } = new();
protected override async Task OnInitializedAsync()
{
await Task.Delay(5000);
LoadPosts();
}
private void LoadPosts()
{
Posts = new()
{
new Post
{
Id = Guid.NewGuid(),
UserName = "Bot Doe",
Content = "What a great day to try the Telerik UI for Blazor Skeleton. The UX feels great while data loads!",
ImageUrl = "https://images.unsplash.com/photo-1500530855697-b586d89ba3ee?q=80&w=1200&auto=format&fit=crop",
PostedAt = DateTimeOffset.UtcNow.AddMinutes(-35)
},
new Post
{
Id = Guid.NewGuid(),
UserName = "Link",
Content = ".NET 10 migration done — everything feels snappier.",
ImageUrl = null,
PostedAt = DateTimeOffset.UtcNow.AddHours(-2)
},
new Post
{
Id = Guid.NewGuid(),
UserName = "Ada Lovelace",
Content = "Pro tip: leverage high-level components to speed up demos.",
ImageUrl = "https://images.unsplash.com/photo-1518837695005-2083093ee35b?q=80&w=1200&auto=format&fit=crop",
PostedAt = DateTimeOffset.UtcNow.AddDays(-1)
}
};
}
private static string GetInitials(string name)
{
if (string.IsNullOrWhiteSpace(name)) return "?";
var parts = name.Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 1) return parts[0].Substring(0, Math.Min(1, parts[0].Length)).ToUpperInvariant();
return (parts[0][0].ToString() + parts[^1][0].ToString()).ToUpperInvariant();
}
private sealed class Post
{
public Guid Id { get; set; }
public string UserName { get; set; } = string.Empty;
public string Content { get; set; } = string.Empty;
public string? ImageUrl { get; set; }
public DateTimeOffset PostedAt { get; set; }
}
}
<style>.feed-container{max-width:820px;margin:0 auto;padding:01rem;}.card{box-shadow:var(--kendo-box-shadow, 01px 3px rgba(0,0,0,0.08));border:1px solid rgba(0,0,0,0.06);border-radius:.5rem;}.composer.k-textarea{width:100%;}.feed img {max-height:420px;object-fit: cover;}.gap-2{gap:.5rem;}.gap-3{gap:1rem;}</style>
If we run the application right now, you can see that we have a poor user experience, as it does not provide feedback that it is trying to fetch information to fill the UI, and you have to wait until the loading is finished to see something on the screen:
Let’s solve this issue by adding the Skeleton component. What you need to do is try to create a copy of the final graphical interface, but replacing each control with the Skeleton component in a suitable shape corresponding to the final component.
For example, a circular shape could be used for the profile picture, a rectangular shape for photographs, and leave the default shape for the text. The following is an example of this replacement in the header of the component CardHeader:
Component CardHeader with the final components rendered
In the previous code, I want you to notice that each type of element has been replaced by the appropriate shape of the Skeleton. In this specific example, I was able to reuse the same containers div to hold the Skeleton components, but if you need to, you can change them to work better for you.
Following this same logic, I am going to create and use a property called IsLoading. This property will allow me to control when to show and hide the loading sections through the creation of a conditional if. In this conditional, we can validate if the loading of the information has concluded, which, if positive, will show the components with information as follows:
In the previous code, you can see that once the loading of information in the method OnInitializedAsync is completed, the value false is assigned to IsLoading, which causes the controls with the final information to be rendered. Also, note that when showing the interface using the Skeleton components, only three items are displayed. The result of the execution is as follows:
With this, you have been able to see how the loading of data in the graphical interface has been incredibly improved.
Conclusion
In this article, you have been able to learn what the Skeleton control for Blazor from Telerik is and how to use it, which is very useful for providing feedback to the user about a process that involves obtaining information to display in the graphical interface. You have seen its different configuration options, as well as an example in a Blazor app where we implemented the component.
Now it’s your turn to enhance the user experience in your applications by implementing the Skeleton component.
Nex Computer runs both Android and this Windows Phone-esque mobile UI that they made in-house.
Nex Computer, a company that makes hardware designed to turn your phone into a laptop, is working on something new: the NexPhone. It's a midrange phone that's designed to double as your computer and comes with Android and Linux installed, both of which will offer desktop experiences when plugged into a monitor.
But the NexPhone's best trick is that it can dual-boot into Windows 11, essentially becoming a full Windows PC when hooked up to a display - and also offers a mobile UI that pays tribute to Windows Phone when it's unplugged. It's a delightfully geeky attempt to answer the age-old question: Why can't your smartphone just be your whol …
The rise of AI Agents marks one of the most exciting shifts in technology today. Unlike traditional applications or cloud resources, these agents are not passive components- they reason, make decisions, invoke tools, and interact with other agents and systems on behalf of users. This autonomy brings powerful opportunities, but it also introduces a new set of risks, especially given how easily AI agents can be created, even by teams who may not fully understand the security implications.
This fundamentally changes the security equation, making securing AI agent a uniquely complex challenge – and this is where AI agents posture becomes critical. The goal is not to slow innovation or restrict adoption, but to enable the business to build and deploy AI agents securely by design.
A strong AI agents posture starts with comprehensive visibility across all AI assets and goes further by providing contextual insights – understanding what each agent can do and what it connected to, the risks it introduces, how it can be harden, and how to prioritize and mitigate issues before they turn into incidents.
In this blog, we’ll explore the unique security challenges introduced by AI agents and how Microsoft Defender helps organizations reduce risk and attack surface through AI security posture management across multi-cloud environments.
Understanding the unique challenges
The attack surface of an AI agent is inherently broad. By design, agents are composed of multiple interconnected layers – models, platforms, tools, knowledge sources, guardrails, identities, and more.
Across this layered architecture, threats can emerge at multiple points, including prompt-based attacks, poisoning of grounding data, abuse of agent tools, manipulation of coordinating agents, etc. As a result, securing AI agents demands a holistic approach. Every layer of this multi-tiered ecosystem introduces its own risks, and overlooking any one of them can leave the agent exposed.
Let’s explore several unique scenarios where Defender’s contextual insights help address these challenges across the entire AI agent stack.
Scenario 1: Finding agents connected to sensitive data
Agents are often connected to data sources, and sometimes -whether by design or by mistake- they are granted access to sensitive organizational information, including PII. Such agents are typically intended for internal use – for example, processing customer transaction records or financial data. While they deliver significant value, they also represent a critical point of exposure. If an attacker compromises one of these agents, they could gain access to highly sensitive information that was never meant to leave the organization. Moreover, unlike direct access to a database – which can be easily logged and monitored – data exfiltration through an agent may blend in with normal agent activity, making it much harder to detect. This makes data-connected agents especially important to monitor, protect, and isolate, as the consequences of their misuse can be severe.
Microsoft Defender provides visibility for those agents connected to sensitive data and help security teams mitigate such risks. In the example shown in Figure 1, the attack path demonstrates how an attacker could leverage an Internet-exposed API to gain access to an AI agent grounded with sensitive data. The attack path highlights the source of the agent’s sensitive data (e.g., a blob container) and outlines the steps required to remediate the threat.
Figure1 – The attack path illustrates how an attacker could leverage an Internet exposed API to gain access to an AI agent grounded with sensitive data
Scenario 2: Identifying agents with indirect prompt injection risk
AI agents regularly interact with external data – user messages, retrieved documents, third-party APIs, and various data pipelines. While these inputs are usually treated as trustworthy, they can become a stealthy delivery mechanism for Indirect Prompt Injection (XPIA), an emerging class of AI-specific attacks. Unlike direct prompt injection, where an attacker issues harmful instructions straight to the model, XPIA occurs where malicious instructions are hidden in external data source that an agent processes, such as a webpage fetched through a browser tool or an email being summarized. The agent unknowingly ingests this crafted content, which embeds hidden or obfuscated commands that are executed simply because the agent trusts the source and operates autonomously.
This makes XPIA particularly dangerous for agents performing high-privilege operations – modifying databases, triggering workflows, accessing sensitive data, or performing autonomous actions at scale. In these cases, a single manipulated data source can silently influence an agent’s behavior, resulting in unauthorized access, data exfiltration, or internal system compromise. This makes identifying agents suspectable to XPIA a critical security requirement.
By analyzing an agent’s tool combinations and configurations, Microsoft Defender identifies agents that carry elevated exposure to indirect prompt injection, based on both the functionality of their tools and the potential impact of misuse. Defender then generates tailored security recommendations for these agents and assigns them a dedicated Risk Factor, that help prioritize them.
in Figure 2, we can see a recommendation generated by the Defender for an agent with Indirect prompt injection risk and lacking proper guardrails – controls that are essential for reducing the possibility of an XPIA event.
Figure 2 – Recommendation generated by the Defender for an agent with Indirect prompt injection risk and lacking proper guardrails.
In Figure 3, we can see a recommendation generated by the Defender for an agent with both high autonomy and a high risk of indirect prompt injection, a combination that significantly increases the probability of a successful attack.
In both cases, Defender provides detailed and actionable remediation steps. For example, adding human-in-the-loop control is recommended for an agent with both high autonomy and a high indirect prompt injection risk, helping reduce the potential impact of XPIA-driven actions.
Figure 3 – Recommendation generated by the Defender for an agent with both high autonomy and a high risk of indirect prompt injection.
Scenario 3: Identifying coordinator agents
In a multi-agent architecture, not every agent carries the same level of risk. Each agent may serve a different role – some handle narrow, task-specific functions, while others operate as coordinator agents, responsible for managing and directing multiple sub-agents. These coordinator agents are particularly critical because they effectively act as command centers within the system. A compromise of such an agent doesn’t just affect a single workflow – it cascades into every sub agent under its control. Unlike sub-agents, coordinators might also be customer-facing, which further amplifies their risk profile. This combination of broad authority and potential exposure makes coordinator agents potentially more powerful and more attractive targets for attackers, making comprehensive visibility and dedicated security controls essential for their safe operation
Microsoft Defender accounts for the role of each agent within a multi-agent architecture, providing visibility into coordinator agents and dedicated security controls. Defender also leverages attack path analysis to identify how agent-related risks can form an exploitable path for attackers, mapping weak links with context.
For example, as illustrated in Figure 4, an attack path can demonstrate how an attacker might utilize an Internet-exposed API to gain access to Azure AI Foundry coordinator agent. This visualization helps security admin teams to take preventative actions, safeguarding the AI agents from potential breaches.
Figure 4 – The attack path illustrates how an attacker could leverage an Internet exposed API to gain access to a coordinator agent.
Hardening AI agents: reducing the attack surface
Beyond addressing individual risk scenarios, Microsoft Defender offers broad, foundational hardening guidance designed to reduce the overall attack surface of any AI agent. In addition, a new set of dedicated agents like Risk Factors further helps teams prioritize which weaknesses to mitigate first, ensuring the right issues receive the right level of attention.
Together, these controls significantly limit the blast radius of any attempted compromise. Even if an attacker identifies a manipulation path, a properly hardened and well-configured agent will prevent escalation.
By adopting Defender’s general security guidance, organizations can build AI agents that are not only capable and efficient, but resilient against both known and emerging attack techniques.
Figure 5 – Example of an agent’s recommendations.
Build AI agents security from the ground up
To address these challenges across the different AI Agents layers, Microsoft Defender provides a suite of security tools tailored for AI workloads. By enabling AI Security Posture Management (AI-SPM) within the Defender for Cloud Defender CSPM plan, organizations gain comprehensive multi-cloud posture visibility and risk prioritization across platforms such as Microsoft Foundry, AWS Bedrock, and GCP Vertex AI. This multi-cloud approach ensures critical vulnerabilities and potential attack paths are effectively identified and mitigated, creating a unified and secure AI ecosystem.
Together, these integrated solutions empower enterprises to build, deploy, and operate AI technologies securely, even within a diverse and evolving threat landscape.
To learn more about Security for AI with Defender for Cloud, visit our website and documentation.
This research is provided by Microsoft Defender Security Research with contributions by Hagai Ran Kestenberg.
Surface is a premium endpoint, designed and built by Microsoft to run Microsoft technology. When it comes to the classroom, Surface Copilot+ PCs bring the best of Microsoft—hardware, Windows, Microsoft 3651, and Microsoft 365 Copilot1—into one teaching device, delivering intelligent experiences more securely on‑device and in the cloud. For educators, this means every lesson and interaction is powered by a device purpose-built for teaching and learning in the digital era.
Why Surface for Education?
Surface Copilot+ PCs, combined with Windows 11, give teachers a powerful platform designed to simplify teaching and elevate learning. With lightning-fast performance, educators can create engaging lessons, generate content, and personalize instruction. Windows 11 features like Snap Layouts, Click to Do2, and Copilot Voice streamline multitasking and lesson prep, while intuitive touch, pen3, and voice input make teaching feel natural. Together, Surface and Windows 11 help deliver a more secure, AI-supported solution that can save time, support creativity, and help teachers focus on what matters most—students.
Engage students with AI-enhanced learning
Picture a classroom where every student is actively engaged, their curiosity sparked by lesson plans and quizzes thoughtfully designed by teachers with the help of AI. Microsoft Learning Zone, included with all Microsoft Education licenses at no extra cost4, is an AI-powered learning app for Windows 11 designed to help educators create engaging lessons. The app’s AI powered lesson creation feature is designed specifically for Copilot+ PCs. Thanks to the Copilot+ PC’s built-in Neural Processing Unit (NPU), these devices offer fast, reliable performance by running AI models directly on the device and combining them with cloud-based capabilities when needed. This hybrid approach helps Microsoft Learning Zone generate lessons quickly and keeps the experience smooth, secure, and ready for classroom use. It also helps educators streamline lesson planning with interactive activities, instant feedback, and personalized learning pathways. For example, teachers can use Microsoft Learning Zone to develop Kahoot! quizzes for a whole class or to prepare individualized learning experiences like personalized practice questions based on recent student performance, while keeping student data more secure and private.
Surface Copilot+ PCs can also help teachers use AI in context to streamline lesson prep and administrative tasks, so they can spend less time on administration and more time inspiring students. For example, teachers can engage with Copilot in a single click using the Copilot key5 on a Surface keyboard or by saying “Hey Copilot” out loud. And using pen, touch, and voice commands in conjunction with Teach in Microsoft 365 Copilot6 running on Surface, teachers have a central hub for generating lesson plans, quizzes, rubrics, flashcards, feedback, and more. They can transform ideas and research into engaging lectures in moments, tailor instruction to meet the needs of every learner, and connect with colleagues to share best practices.
Recently, we also announced the Microsoft Elevate for Educators skilling program along with more AI-powered experiences purpose-built for education, including the Study and Learn agents in Microsoft 365 Copilot, and Study Guide. Microsoft Elevate helps equip educators with the AI skills they need for the classroom of the future. Delivered through platforms like Microsoft Learn and Minecraft Education, these flexible learning paths ensure that educators can build AI fluency at their own pace, whether they're just beginning their journey or advancing to specialized applications. Read more about Microsoft Elevate and other AI tools for education here.
In classrooms where both teachers and students are using Surface Copilot+ PCs, Live Captions7 with on-device automatic translation can help make spoken content accessible to all students, including students with hearing impairments. The NPU transcribes and translates audio in real time, supporting 40+ languages into English, all processed on-device versus the cloud.
Ideally with Surface Copilot+ PCs and Microsoft’s AI-powered tools, technology fades into the background in the classroom, helping teacher creativity and connection take center stage and enabling student learning to be more dynamic, inclusive, and impactful.
Empower the classroom of the future, today
Surface Copilot+ PCs, purpose-built by Microsoft, are designed to be the foundation for today’s classrooms and the launchpad for tomorrow’s AI innovations. With Windows evolving as the canvas for intelligent AI and agents, Surface devices and Windows together form an essential, AI-assisted platform for educators.
Now, every teacher can activate Copilot agents8 directly on their Surface device to act as a digital teaching partner. These agents can adapt to each teacher’s unique style, streamline daily routines, and unlock new possibilities for student learning. Building agents is simple: teachers or IT can use ready-made templates or create custom agents using natural language, all within the familiar Surface and Windows environment.
Surface’s intuitive hardware—touchscreen, pen, voice, and the dedicated Copilot key—makes accessing AI support effortless. Teachers can get immediate answers to classroom questions, troubleshoot tech issues, or navigate school resources using natural input methods. By combining Copilot’s intelligent capabilities with Surface’s secure hardware, educators can gain a more personalized, efficient, and protected teaching experience ready for the future of learning.
In addition, Surface Copilot+ PCs help support the full range of learning needs by delivering the performance and experience required for the education tools students and educators depend on every day. Surface devices are designed to work with common education apps like TestNav for assessments, Minecraft Education for STEM, Adobe Express for creativity, and assistive technologies such as JAWS.
And, going forward, the built-in NPU on Copilot+ PCs like Surface enables Microsoft and other educational software providers to develop innovative new AI experiences that can run on the device, in the cloud, or both.
Boost productivity and collaboration
In the classroom, Surface Copilot+ PCs can become the teaching command center: always ready, always responsive. With a simple voice command, Copilot Voice and improved Windows Search9 instantly pull up lesson plans, student materials, or answers to unexpected questions, freeing instructors from frantic searches and giving back precious prep time.
Collaborating on Surface is intuitive and efficient. Teachers can quickly save lesson materials in Teams or OneDrive1 and share them with students for interactive feedback. Whether teachers are leading a lively discussion in person, connecting with students remotely, or conferencing with colleagues via video, Windows Studio Effects on Copilot+ PCs ensure they’re always seen and heard clearly. Subtle features like background blur, eye contact, and automatic framing help maintain a professional presence, so the focus stays on interacting with students or other teachers—not on the tech.
And Surface Copilot+ PCs are designed to empower mobility in and outside the classroom. With extended battery life and lightweight devices, teachers are no longer tethered to a desk or a charger. They can move about freely, interact with students, project and present seamlessly, and focus on teaching. For example, on a Surface Pro with Surface Pen inking, Dual Studio Mics, and natural language prompts in Copilot, teachers can annotate readings, capture ideas by voice, and generate lesson materials on the fly—without breaking the flow of instruction.
Throughout the day, Surface Copilot+ PCs can also help teachers anticipate what’s next. Context-aware Windows Search doesn’t just find files—it suggests smart next steps, like opening a document in Word or sharing it with a colleague, streamlining workflows. When inspiration for a lesson strikes, Click to Do lets teachers quickly summarize, explain, or create new content on the fly, helping them build engaging lectures and materials in real time. Surface’s vibrant touchscreen and Snap Layouts can help keep resources organized and visible, supporting a productive work experience.
And, most importantly, Surface devices help safeguard faculty, staff, students, and sensitive school data with advanced security and remote management features1. As innovations advance in AI, Microsoft and Surface provide built-in protection at every layer—hardware, firmware, operating system, cloud, software applications, and identity.
Surface Copilot+ PCs are more than just devices—they’re partners in teaching, learning, and innovation. By combining Microsoft’s advanced hardware, intuitive software, and powerful AI, Surface empowers educators to engage students, boost productivity, and modernize their classrooms, all while keeping data more secure and private.
Sold separately. Software license required for some features.
Click to Do. Copilot+ PC feature. Image actions now available across devices; other actions vary by device, region, language, and character sets. Subscription required for some actions. Learn more.
Surface Pen sold separately. Surface Slim Pen (2nd Edition) experiences and compatibility vary by which Surface device you are using it with. Visit Surface Slim Pen Compatibility to learn more.
Microsoft Learning Zone requires a Microsoft 365 Education Essentials, Core (A3), or Advanced (A5) license. Microsoft Education licenses.
Copilot key feature availability varies by market, see aka.ms/keysupport.
Copilot+ PC feature. Live Captions translates video and audio subtitles into English from 40+ languages and from 25+ languages into Chinese (Simplified). See Copilot+ PC FAQs.
Copilot with commercial data protection is available at no additional cost for users with an Entra ID with an enabled, eligible Microsoft 365 license. Copilot for Microsoft 365 sold separately and requires a qualifying volume license or subscription - Microsoft Copilot for Microsoft 365 | Microsoft 365. Minimum age limits apply to use of Copilot and certain AI features. Details.
Copilot+ PC feature. Improved Windows search works with specific text, image, and document formats only; optimized for select languages (English, Chinese (Simplified), French, German, Japanese, and Spanish). See Copilot+ PC FAQs.
Log in
