AI Debug Assistant: MCP-Powered Debugging for Embedded

The AI Debug Assistant is an agentic debugging system built into CodeFusion Studio that actively participates in live debug sessions, autonomously investigating hardware faults, reading register and memory state, and coordinating across multiple cores — all in real time, using natural language.

The AI Debug Assistant is currently in preview and may change in future releases.

Rather than answering static questions about source code, the AI Debug Assistant can autonomously investigate hardware faults, read live register and memory state, coordinate across multiple cores, set hardware watchpoints, and reason about what the silicon is actually doing — all in real time, using natural language. It bridges the gap between a passive code assistant and a fully capable embedded debugging partner.

What makes it different

Traditional AI code assistants work with static source. The AI Debug Assistant connects to a live debug session through the Model Context Protocol (MCP) — an open standard created by Anthropic for connecting AI models to external tools and data sources. This means the AI has access to actual hardware state: the contents of fault registers, live memory values, the call stack at the moment of a crash, and the execution state of every core in a multi-core system. When you ask “What caused this hard fault?”, the assistant does not guess from source code. It reads the ARM Cortex-M fault status registers (CFSR, HFSR, BFAR, MMFAR), decodes the exception type, inspects the faulting address against the memory map, and walks the call stack to the offending source line — all autonomously.

Integration paths

CFS MCP Debug Server (Recommended)

An MCP-based HTTP server built into the CFS IDE extension. Works with GitHub Copilot Agent Mode, Claude Code, and any MCP-compatible AI client. Enables fully agentic, multi-step investigations.

CFS Debug Chat Participant

A VS Code GitHub Copilot Chat integration accessed via the @cfs-debug participant. Works without starting the MCP server. Best for quick, single-step interactions within VS Code.

For production workflows, use the CFS MCP debug server with any MCP-compatible AI client for maximum portability and future compatibility. Use the @cfs-debug chat participant for quick interactions without setup.

What the assistant can do

Capability	Description
Session control	Start, stop, restart, continue, pause, and step through debug sessions
Hardware state inspection	Read registers, memory, variables, stack traces, and thread lists directly from the target
Breakpoints and watchpoints	Set, list, and remove breakpoints — including conditional breakpoints — and hardware watchpoints
GDB command execution	Run GDB commands with built-in safety guards that block destructive operations
Fault decoding	Automatically parse ARM Cortex-M fault registers (CFSR, HFSR, BFAR, MMFAR) and RISC-V exception registers (mcause, mtval, mepc)
ELF binary analysis	Surface symbol sizes, stack usage, section layout, and the largest consumers of flash and RAM
Structured diagnostic prompts	Pre-built investigation sequences for crash diagnosis, memory corruption, peripheral misconfiguration, multi-core debugging, and more

Getting started with the MCP debug server

Prerequisites

CodeFusion Studio installed with an active project
For GitHub Copilot Agent Mode: VS Code 1.96.0 or later and the GitHub Copilot extension installed and authenticated
For Claude Code: Claude Code CLI installed

Start the MCP server

Open the Command Palette (Ctrl+Shift+P / Cmd+Shift+P) and run:

(CFS) MCP: Start Debug Server

A VS Code notification appears with the URL the server is listening on, for example http://localhost:56448/mcp. Note the port number — you will need it to connect AI clients.The following commands manage the server:

Command	Description
`(CFS) MCP: Start Debug Server`	Start the MCP server
`(CFS) MCP: Stop Debug Server`	Stop the MCP server
`(CFS) MCP: Server Status`	Check whether the server is running and which port it is using

(Optional) Set a fixed port

By default, the OS assigns an available port at startup. For a stable registration URL (recommended for Claude Code), set a fixed port:

Go to Settings → Extensions → CodeFusion Studio → General, or search for cfs.mcp.port.
Set Port to a specific value (for example, 3001). Set to 0 to restore OS-assigned behavior.
Restart the MCP server: run Stop Debug Server then Start Debug Server.

Connect GitHub Copilot Agent Mode

Open GitHub Copilot Chat (Ctrl+Alt+I / Cmd+Shift+I).
Click the mode selector dropdown in the chat input (defaults to Ask).
Select Agent.

When VS Code MCP support is enabled, Agent Mode automatically discovers and uses the running MCP server. No manual registration is needed — GitHub Copilot reads the port directly from the cfs.mcp.port setting.

Connect Claude Code

Check the server URL via (CFS) MCP: Server Status, then register the server:

claude mcp add --transport http cfs-debug http://localhost:<port>/mcp

Exit and restart Claude Code for the registration to take effect. Verify with:

claude mcp list

Start a debug session

Press F5 or click the Run and Debug icon to start a CFS debug session. The AI assistant needs an active session to inspect hardware state. Alternatively, ask the assistant: “Start debugging CFS: Debug with GDB and OpenOCD (ARM Embedded)”.

Ask your first question

In Agent Mode or Claude Code, describe what you want investigated in natural language:

What is the current execution state of the target?

What caused this hard fault?

The assistant plans and executes a sequence of debug operations autonomously and reports its findings.

To start the MCP server automatically whenever the CFS extension activates, enable Settings → Extensions → CodeFusion Studio → General → MCP Server → Run on Activation (cfs.mcp.runOnActivation).

Getting started with the chat participant

For quick interactions within VS Code without setting up the MCP server:

Ensure prerequisites

Install VS Code 1.96.0 or later and the GitHub Copilot extension. Sign in to GitHub Copilot.

Open GitHub Copilot Chat

Press Ctrl+Alt+I / Cmd+Shift+I to open the Copilot Chat panel.

Type @cfs-debug

Prefix your message with @cfs-debug. The assistant routes your input to the appropriate debug operation:

@cfs-debug show registers
@cfs-debug what caused this hard fault?
@cfs-debug set breakpoint at main.c:42

For AI analysis features, use a Claude model (such as Claude Sonnet 4.5 or Claude Opus 4.6) with the @cfs-debug chat participant. Other models may work for basic commands but can produce inconsistent results for analysis tasks.

Using the assistant during a live debug session

Natural language investigations (MCP server)

With the MCP server running and a debug session active, describe the problem in plain language. The assistant determines the investigation sequence autonomously:

Investigate the shared memory issue between both cores.

Diagnose why the application hard-faulted after 30 seconds of runtime.

Find what's writing to the shared buffer and causing data corruption.

The assistant plans and executes the sequence — reading registers, inspecting memory, setting watchpoints, walking call stacks — and reports its findings when complete.

Chat participant commands (`@cfs-debug`)

Session control
Breakpoints
Hardware state
GDB commands
AI analysis

@cfs-debug start debugging with CFS: Debug with GDB and OpenOCD (Arm Embedded)
@cfs-debug stop debugging
@cfs-debug restart
@cfs-debug continue
@cfs-debug step over
@cfs-debug step into
@cfs-debug step out
@cfs-debug pause

@cfs-debug set breakpoint at main.c:42
@cfs-debug set breakpoint at main.c:42 if counter > 10
@cfs-debug list breakpoints
@cfs-debug clear all breakpoints
@cfs-debug remove breakpoint at main.c:42

@cfs-debug show variables
@cfs-debug show registers
@cfs-debug show stack trace
@cfs-debug read memory at 0x20000000

Output is formatted as markdown tables for variables and registers, annotated stack frames, and hex dumps for memory — displayed directly in the chat panel.

@cfs-debug gdb: backtrace
@cfs-debug info registers
@cfs-debug print myVariable
@cfs-debug run gdb command: info locals

Destructive GDB commands (quit, kill, detach, file, target) are blocked by the assistant and will not be forwarded to the active session.

@cfs-debug what caused this hard fault?
@cfs-debug find bugs
@cfs-debug why is this variable null?
@cfs-debug explain the current stack trace

The assistant gathers context from the live session — registers, local variables, stack frames — and constructs a grounded explanation based on actual hardware state.

Real-world examples

Diagnosing a hard fault

Your firmware hits a hard fault. In Agent Mode or Claude Code:

“What caused this hard fault?”

The AI Debug Assistant:

Reads the ARM Cortex-M fault status registers (CFSR, HFSR, BFAR, MMFAR)
Decodes the exception type: bus fault, memory management fault, usage fault, or hard fault
Inspects the faulting address against the memory map
Walks the call stack to identify the offending function and source line
Reports the root cause in plain language with the relevant file and line number

Tracking a multi-core shared memory race condition

A dual-core SoC (Cortex-M33 + Cortex-M4) shares a region of SRAM. Under load, the application core intermittently reads stale values — no crash, no fault, just wrong data.

“Investigate the shared memory issue between both cores.”

The AI Debug Assistant:

Connects to debug sessions on both cores
Reads the shared memory region and inspects ELF-mapped variables
Examines the execution state of each core — what each was running, what addresses each was accessing
Identifies that the DMA transfer on Core 1 overlaps with Core 0’s buffer read with no synchronization primitive
Reports the conflicting memory region, the source lines involved, and a suggested fix

Tracing memory corruption with a watchpoint

A variable is being corrupted and you don’t know where.

“Watch shared_buffer for writes and tell me what’s writing to it.”

The AI Debug Assistant:

Locates the variable in the ELF symbol table to get its address
Sets a hardware watchpoint on that address
Continues execution and waits for the watchpoint to fire
Reads the call stack at the point of the write
Disassembles the surrounding code to identify the root cause
Reports the offending function, source line, and the value written

Analyzing firmware binary size

Before a release, you need to reduce flash usage.

“Analyze the firmware binary and show me the largest consumers of flash and RAM.”

The assistant reads the ELF binary, surfaces symbol sizes and section layout, ranks the largest contributors, and suggests optimization candidates — without requiring you to manually run arm-none-eabi-nm and sort the output.

MCP tools reference

The CFS MCP debug server exposes tools organized into six categories. All tools are available to any connected MCP-compatible client.

Tool	Description	Parameters
`debug_execute_gdb_command`	Execute a single GDB command. Destructive commands are blocked.	`command`
`debug_execute_gdb_sequence`	Execute a sequence of GDB commands in order. Session must be halted.	`commands` (array, 1–20), `stopOnError` (optional)

Tool	Description	Parameters
`debug_get_active_session`	Get information about the active debug session	—
`debug_start`	Start a debug session	`configName`
`debug_stop`	Stop the current debug session	—
`debug_restart`	Restart the current debug session; re-flashes and relaunches	—

Tool	Description	Parameters
`debug_continue`	Continue program execution	—
`debug_step_over`	Step over the current line	—
`debug_step_into`	Step into a function call	—
`debug_step_out`	Step out of the current function	—
`debug_pause`	Pause program execution	—
`debug_get_execution_state`	Get current execution state; includes stop reason when halted	—
`debug_wait_for_stop`	Block until the target halts; returns the stop reason	`timeoutMs` (optional, 100–300000)

Tool	Description	Parameters
`debug_set_breakpoint`	Set a breakpoint at a file/line with optional condition	`file`, `line`, `condition` (optional)
`debug_remove_breakpoints`	Remove breakpoints from a file or all breakpoints	`file` (optional), `line` (optional)
`debug_list_breakpoints`	List all active breakpoints	—
`debug_set_watchpoint`	Set a hardware watchpoint on memory write, read, or access	`expression`, `type` (optional: `write`/`read`/`access`)
`debug_remove_watchpoint`	Remove a watchpoint by number	`number`

Tool	Description	Parameters
`debug_read_memory`	Read memory bytes from the target	`address`, `count` (1–1024 bytes)
`debug_write_memory`	Write a value to a memory address; verified by read-back	`address`, `value` (hex), `size` (optional)
`debug_search_memory`	Search for a byte pattern in a memory region	`startAddress`, `length` (1–1,048,576 bytes), `pattern`

Tool	Description	Parameters
`debug_get_context`	Get comprehensive context: backtrace, registers, and local variables	—
`debug_analyze_fault`	Read and decode fault registers for ARM Cortex-M or RISC-V	`architecture` (`arm` or `riscv`)
`debug_search_source`	Search workspace source files for a pattern or symbol name	`pattern`, `fileGlob` (optional), `maxResults` (optional)

Diagnostic prompts reference

Pre-built diagnostic prompts encode systematic debugging methodologies. Invoke them by describing the task in natural language, or by name in any MCP-compatible client. In Claude Code, run /mcp to browse all available prompts.

Prompt	What it does	Parameters
`basic-state-awareness`	Reports execution state, program counter, and stack pointer	—
`crash-diagnosis`	Waits for a crash, decodes fault registers, walks call stack, identifies offending function	—
`breakpoint-and-inspect`	Sets a breakpoint, continues, reports local variables when hit	`file`, `line`
`source-search-and-debug`	Finds code matching a description, sets a breakpoint, inspects registers	`description`
`conditional-breakpoint`	Sets a conditional breakpoint, catches it twice, reads a variable each time	`condition`, `variable` (optional)
`step-and-disassemble`	Steps N instructions, showing disassembly and a register value at each step	`steps` (optional), `register` (optional)
`watchpoint-trigger`	Watches a variable for writes, reports what wrote to it with the full call stack	`variable`
`memory-inspection`	Reads a memory region; identifies ASCII strings, structured data, or byte patterns	`address`, `length` (optional)
`autonomous-investigation`	End-to-end memory corruption investigation: locates struct in ELF, sets watchpoint, traces root cause	`variable`
`timeout-handling`	Sets a breakpoint on a function and reports what happens; useful for testing error paths	`functionName`

Settings reference

Setting	Description	Default
`cfs.mcp.runOnActivation`	Automatically start the MCP server when the CFS extension activates	`false`
`cfs.mcp.port`	Port for the MCP server. Set to `0` for OS-assigned port.	`0`

Troubleshooting

MCP server port conflict

If the OS cannot assign a port, or you need a specific port:

Open Settings and search for cfs.mcp.port.
Set Port to a specific free port (for example, 3001). Use 0 for OS-assigned.
Run Stop Debug Server then Start Debug Server.
Update your AI client registration to use the new port.

No active debug session

Most tools require an active debug session. Start debugging with F5 or the Run menu before asking the assistant to inspect hardware state. Alternatively, ask the assistant directly: “Start debugging CFS: Debug with GDB and OpenOCD (ARM Embedded)”.

No Copilot model available

If you see No Copilot model available. Please ensure GitHub Copilot is installed and authenticated:

Verify GitHub Copilot is installed and you are signed in.
Confirm your GitHub Copilot plan includes access to Claude models (Claude Sonnet 4.5 or Claude Opus 4.6).

CFS Debug Assistant tools not appearing in GitHub Copilot Chat

Check that VS Code is version 1.96.0 or later (Help → About).
Ensure GitHub Copilot is installed and authenticated.
Confirm the CodeFusion Studio extension is installed and active.
If MCP support is unavailable in your VS Code environment, use the @cfs-debug chat participant or Claude Code instead.

Claude Code cannot connect to the MCP server

Run (CFS) MCP: Server Status to confirm the server is running.
Run claude mcp list to verify cfs-debug is registered with the correct URL and port.

If the port has changed since registration, re-register:

claude mcp remove cfs-debug
claude mcp add --transport http cfs-debug http://localhost:<port>/mcp
claude mcp list

To test the server independently, use the open-source MCP Inspector:

npx @modelcontextprotocol/inspector

Select Streamable HTTP transport and Via Proxy connection type, then enter http://localhost:<port>/mcp. Browse all available tools and prompts to verify the server is working before involving an AI client.

Agent Mode does not show CFS MCP server tools

If Agent Mode does not discover the CFS MCP server, verify that MCP support is enabled in your VS Code installation. If MCP support is unavailable, use the @cfs-debug chat participant or connect with Claude Code instead.

Get Started

Workspace & System Planner

Build, Flash & Debug

Embedded AI

Developer Tools

AI Debug Assistant: MCP-Powered Debugging for Embedded

What makes it different

Integration paths

CFS MCP Debug Server (Recommended)

CFS Debug Chat Participant

What the assistant can do

Getting started with the MCP debug server

Prerequisites

Getting started with the chat participant

Using the assistant during a live debug session

Natural language investigations (MCP server)

Chat participant commands (`@cfs-debug`)

Real-world examples

MCP tools reference

Diagnostic prompts reference

Settings reference

Troubleshooting

Build docs developers (and LLMs) love

Get Started

Workspace & System Planner

Build, Flash & Debug

Embedded AI

Developer Tools

Documentation Index

​What makes it different

​Integration paths

CFS MCP Debug Server (Recommended)

CFS Debug Chat Participant

​What the assistant can do

​Getting started with the MCP debug server

​Prerequisites

​Getting started with the chat participant

​Using the assistant during a live debug session

​Natural language investigations (MCP server)

​Chat participant commands (@cfs-debug)

​Real-world examples

​MCP tools reference

​Diagnostic prompts reference

​Settings reference

​Troubleshooting

Build docs developers (and LLMs) love

What makes it different

Integration paths

What the assistant can do

Getting started with the MCP debug server

Prerequisites

Getting started with the chat participant

Using the assistant during a live debug session

Natural language investigations (MCP server)

Chat participant commands (`@cfs-debug`)

Real-world examples

MCP tools reference

Diagnostic prompts reference

Settings reference

Troubleshooting