"Your AI can read every line of your code — but it has never watched it run. Until now."

Debugging is the last frontier of AI-assisted development. Code generation, refactoring, and test writing are solved problems — but when a bug hides in runtime state, your AI assistant is blind. Agentic Debugging gives AI agents eyes into the running process: breakpoints, call stacks, variables, and expression evaluation — all controlled programmatically through open protocols. Come see what happens when an AI doesn't just read your code, but steps through it.
Session Outline:
1. The Problem — AI assistants can read code but cannot observe runtime state. They guess at bugs instead of proving them. We close this gap.
2. Architecture Deep-Dive — Two delivery modes sharing one backend-agnostic tool layer:
VS Code LM Tools — 16 tools registered via vscode.lm.registerTool(), Copilot agent mode controls breakpoints, stepping, variables, and expression evaluation while the developer sees the full native debug UI.
MCP Server — 20 tools over stdio/Streamable HTTP for CLI clients, Cursor, Windsurf, and any MCP-compatible host. Multi-instance management with heartbeat monitoring.
3. Strict Debug Flow & Tool Schema — Custom debug agent with enforced state-machine transitions (launch → listen → connect → pause → inspect → step → terminate), typed JSON schemas, and efficiency-optimized tool descriptions that eliminate wasted LLM calls.
4. Multi-Language & CLI Bridge — Extending beyond PHP/Xdebug to Node.js, Python, and Go through the DebugBackend interface abstraction and a CLI bridge for headless environments.
5. Agent Skills, Playwright Integration & MCP Resources — Agent instruction sets that encode debugging heuristics, Playwright-driven HTTP request triggering so the agent completes the full debug cycle autonomously, and MCP Resources exposing breakpoints, call stacks, and session state as read-only context.
6. Live Demo — Agent autonomously reproduces a bug, sets strategic breakpoints, inspects runtime state, and reports root cause.

Prerequisite

Familiarity with VS Code debugging — you've used breakpoints, the call stack panel, and the variables view at least a few times
Basic understanding of what LLMs/AI agents are — no ML expertise needed, just awareness that tools like Copilot and Cursor exist and can call functions
Optional but helpful: exposure to the Model Context Protocol (MCP) or Debug Adapter Protocol (DAP) concepts; we'll explain both from first principles during the session
No specific language expertise required — demos use PHP and Drupal but the architecture is language-agnostic

Target Audience

Developers

Outline

Debugging is no longer a solo activity. This session introduces Agentic Debugging — an open-source architecture that gives AI agents first-class access to the Debug Adapter Protocol (DAP) through VS Code Language Model Tools and the Model Context Protocol (MCP).

Learning Objectives

1. Understand the Agentic Debugging architecture — how Language Model Tools and MCP bridge the gap between AI agents and runtime debugging
2. Design strict tool schemas for reliable agent behavior — learn how enforced state-machine flows, typed JSON input schemas, and efficiency-focused modelDescription prompts reduce wasted LLM calls and prevent invalid tool sequences
3. Implement a debug session lifecycle controlled by an AI agent — from launch through breakpoint placement, event-driven waiting, variable inspection, and hypothesis-driven stepping to termination
4. Extend the approach to your own stack — apply the DebugBackend interface pattern, CLI bridge, Playwright request triggering, and MCP Resources to add agentic debugging for any language supported by DAP (Node.js, Python, Java, etc.)

Experience level
Advanced