{"id":935,"date":"2026-10-06T11:14:28","date_gmt":"2026-10-06T18:14:28","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/?p=935"},"modified":"2026-10-07T20:54:56","modified_gmt":"2026-10-08T03:54:56","slug":"introducing-windbg-mcp-debug-with-natural-language-grounded-in-evidence","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/introducing-windbg-mcp-debug-with-natural-language-grounded-in-evidence\/","title":{"rendered":"Introducing WinDbg MCP: Debug with natural language, grounded in evidence"},"content":{"rendered":"

Debugging rarely starts with a clear answer. An app crashes, a service hangs, a driver fails, or a kernel dump offers few clues. Whether you\u2019re working with a live target, crash dump, or Time Travel Debugging (TTD) trace, the first question is the same: <\/span>Where do I start, and what should I investigate next?<\/span><\/b>\u00a0<\/span><\/p>\n

Today we\u2019re introducing <\/span>WinDbg MCP<\/span><\/b><\/a>, a natural-language interface for WinDbg built on Model Context Protocol (MCP). It connects AI clients such as <\/span>GitHub Copilot CLI<\/span><\/a> and <\/span>Visual Studio Code<\/span><\/a> to an active WinDbg session, so you can investigate user-mode and kernel-mode crashes and hangs in plain language, grounded in debugger evidence.<\/span>\u00a0<\/span>With safeguards on by default and AI-initiated actions visible in WinDbg, you move from symptoms to evidence-backed hypotheses and clear next steps while staying in control.<\/span>\u00a0<\/span><\/p>\n

The <\/span>Diagnostician<\/span><\/b><\/a> skill adds a structured, repeatable root-cause workflow for apps, services, UMDF drivers, and kernel-mode drivers. It treats pattern matches as hypotheses, tests alternatives, and delivers candidate root causes with targeted next steps and clear evidence gaps.<\/span>\u00a0<\/span><\/p>\n

What is WinDbg MCP?<\/strong><\/h3>\n

WinDbg MCP is an MCP server in WinDbg that connects AI clients to a live WinDbg session through a local proxy. You can ask an AI client to inspect the current target, run debugger commands, review diagnostics and source code, visualize debugger data, or create scripts for repeatable analysis.<\/span>\u00a0<\/span><\/p>\n

Currently, officially supported AI clients are <\/span>Visual Studio Code<\/span><\/a> and <\/span>GitHub Copilot CLI<\/span><\/a>. <\/span>Claude Code<\/span><\/a> may work if you disable cross-prompt injection protection, which we don\u2019t recommend.\u00a0<\/span>See\u00a0Using other MCP clients<\/em>\u00a0in\u00a0Get Started<\/strong>\u00a0for details.<\/span><\/p>\n

Why we built it<\/strong><\/h3>\n

We built WinDbg MCP so in GitHub Copilot CLI <\/span><\/span><\/span>or VS<\/span><\/span><\/span> Code Copilot\u00a0<\/span><\/span><\/span>you can ask something as simple as: <\/span>\u201cRoot cause this crash, show the supporting evidence, and state any unverified assumptions.\u201d<\/span><\/i> Getting from a symptom to a defensible root cause used to mean knowing which WinDbg commands to run, how to read their output, and what evidence to gather next. That was a high bar for new developers and a time sink for experienced ones.<\/span>\u00a0<\/span><\/p>\n

Now you describe the problem in natural language, and skills such as Diagnostician add a repeatable process for gathering evidence, testing hypotheses, and flagging what remains unknown. New users can start without mastering the command set and learn as they go by watching the AI-driven commands run in WinDbg. Experienced engineers can move faster through repetitive analysis and focus on validating the root cause and choosing the right fix.<\/span>\u00a0<\/span><\/p>\n

Get Started<\/strong><\/h3>\n

WinDbg MCP is included starting with version 1.2610.1001.0 and available from the Microsoft Store<\/a> and WinDbg download page<\/a>.<\/p>\n

    \n
  1. Open WinDbg and go to\u00a0MCP service settings<\/strong>.<\/li>\n
  2. Ensure\u00a0Enable Server<\/strong>\u00a0is selected and choose\u00a0VS Code<\/strong>\u00a0or\u00a0GitHub Copilot CLI<\/strong>.<\/li>\n
  3. Select\u00a0Install MCP<\/strong>\u00a0to register WinDbg with the selected client.<\/li>\n
  4. Select\u00a0MCP Service<\/strong>, review the Privacy and Security Warning and the Secure Mode option, and then select Yes<\/strong> to start the service.<\/li>\n
  5. Load or attach to a debugging target.<\/li>\n
  6. Select\u00a0Open Chat<\/strong>\u00a0and start your investigation.<\/li>\n<\/ol>\n

    The following demo shows a user connecting GitHub Copilot CLI to an active WinDbg session and beginning an investigation: View demo full size<\/a><\/p>\n

    \"WinDbg<\/a><\/p>\n

    For detailed setup instructions and prerequisites, see Set up and use WinDbg MCP<\/a>. To report a problem or suggest an improvement, visit the\u00a0WinDbg Feedback repository<\/a>.<\/p>\n

    Using other MCP clients:<\/strong> Other MCP-compatible clients, such as Codex and Claude Code, may work with custom configuration on a best-effort basis. Because these clients <\/span>don\u2019t<\/span> currently support MCP sampling, using them <\/span><\/span>require<\/span><\/span>s<\/span><\/span><\/span> turning off cross-prompt injection protection. Consider the reduced protection before connecting to a target.<\/span><\/span>\u00a0<\/span><\/p>\n

    Example debugging flow<\/strong><\/h3>\n

    Imagine opening a crash dump without knowing where the failure began.\u00a0Start by describing what you want to understand:<\/p>\n\n\n\n
    Analyze this crash dump and identify the likely root cause. Include supporting debugger evidence and any assumptions that remain unverified.<\/em><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    WinDbg MCP can inspect the target using relevant debugger tools and organize the findings into an initial hypothesis. You can then ask what evidence supports the conclusion, which alternatives remain, and what to investigate next.<\/p>\n

    Structured root-cause triage with Diagnostician<\/span><\/b>\u00a0<\/span><\/h3>\n

    Diagnostician brings Windows-specific debugging playbooks to GitHub Copilot CLI through WinDbg MCP. It runs a repeatable five-phase investigation, treats pattern matches as hypotheses, and reports candidate root causes with targeted validation steps. It supports apps, services, user-mode drivers (including UMDF), and kernel-mode drivers.<\/span>\u00a0<\/span><\/p>\n

    Diagnostician is part of the\u202f<\/span>windbg\u202fplugin<\/span><\/a> in the public\u202f<\/span>win-dev-skills<\/span><\/a>\u202fcatalog. With Git and GitHub Copilot CLI installed, your target loaded in WinDbg, and the MCP service connected:<\/span>\u00a0<\/span><\/p>\n

      \n
    1. Add the catalog:\u202fcopilot plugin marketplace add microsoft\/win-dev-skills<\/span>\u00a0<\/span><\/li>\n
    2. Install the plugin:\u202fcopilot plugin install windbg@win-dev-skills<\/span>\u00a0<\/span><\/li>\n
    3. Start a new Copilot CLI session and enter:<\/span>\u202f<\/span><\/li>\n<\/ol>\n\n\n\n
      Root cause the dump in the debugger. Let the diagnostician orchestrate the debugging session, test alternative explanations, and state what evidence is missing.<\/span><\/i><\/em><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Steps 1 and 2 are one-time setup. For a saved report, use the full investigation prompt in the windbg plugin <\/span>README<\/span><\/a>. When Copilot CLI can write files, it saves a Markdown report to\u202f.diagnoses\\<short-id>\\<yyyyMMdd-HHmmss>.md\u202fin the working directory.<\/span>\u00a0<\/span><\/p>\n

      Using a different AI client? See the note on other MCP clients in <\/span><\/i>Get Started<\/span><\/i><\/b>, including the cross-prompt injection consideration.\u00a0<\/span><\/i>\u00a0<\/span><\/p>\n

      How it works<\/strong><\/h3>\n

      \"WinDbgMCP<\/a><\/p>\n

      WinDbg MCP uses a local proxy to connect an AI client to a specific WinDbg session. The debugger connection remains local, while the AI client communicates with its configured model service according to that client\u2019s configuration and data-handling policies.<\/p>\n

      When you ask a question, the AI client can invoke relevant WinDbg MCP tools based on the request. WinDbg performs the requested debugger actions and returns the results to the client for analysis. The actions remain visible in WinDbg so you can review what was run and validate the resulting findings. Only one active MCP client can connect to a WinDbg session at a time. If multiple sessions are available, you can select the one you want to investigate.<\/p>\n

      Built-in security protections<\/strong><\/h3>\n

      WinDbg MCP includes safeguards designed for AI-assisted debugging. AI-initiated actions are recorded in logs, providing an auditable record of what was run.<\/p>\n

      Secure Mode<\/strong>\u00a0restricts high-risk operations, including loading or executing untrusted code, launching processes, and performing unsafe file operations. The option to enter Secure Mode is selected by default when you start MCP. Start MCP before connecting to a target for full Secure Mode. If a target is already connected, WinDbg enters partial Secure Mode and displays a warning. Once enabled, Secure Mode remains active until WinDbg restarts.<\/p>\n

      Cross-prompt injection protection<\/strong>\u00a0checks debugger command output for content that could mislead the AI into unsafe actions. For protected operations, WinDbg uses the AI client\u2019s configured model service to classify the output and blocks content identified as potentially unsafe. This protection requires a client that supports and permits MCP sampling and may use additional AI tokens.<\/p>\n

      Disable these protections only when working with an authorized target in a trusted environment and when doing so is permitted by your organization\u2019s security and data-handling policies. For details, see the WinDbg MCP overview<\/a>.<\/p>\n

      Use AI-assisted debugging responsibly<\/strong><\/h3>\n

      Built-in safeguards reduce risk, but AI-generated findings may still be incomplete or incorrect. Validate important conclusions against the target state and evidence visible in WinDbg, and review any generated or modified scripts before running them.<\/p>\n

      The AI client may send debugging context to its configured model service. Use WinDbg MCP only with authorized targets and in accordance with your organization\u2019s AI, security, privacy, and data-handling policies.<\/p>\n","protected":false},"excerpt":{"rendered":"

      Debugging rarely starts with a clear answer. An app crashes, a service hangs, a driver fails, or a kernel dump offers few clues. Whether you\u2019re working with a live target, crash dump, or Time Travel Debugging (TTD) trace, the first question is the same: Where do I start, and what should I investigate next?\u00a0 Today […]<\/p>\n","protected":false},"author":218665,"featured_media":76,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-935","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-performance-diagnostics"],"acf":[],"blog_post_summary":"

      Debugging rarely starts with a clear answer. An app crashes, a service hangs, a driver fails, or a kernel dump offers few clues. Whether you\u2019re working with a live target, crash dump, or Time Travel Debugging (TTD) trace, the first question is the same: Where do I start, and what should I investigate next?\u00a0 Today […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/posts\/935","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/users\/218665"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/comments?post=935"}],"version-history":[{"count":2,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/posts\/935\/revisions"}],"predecessor-version":[{"id":982,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/posts\/935\/revisions\/982"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/media\/76"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/media?parent=935"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/categories?post=935"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/performance-diagnostics\/wp-json\/wp\/v2\/tags?post=935"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}