The Complete Windows Guide to Claude Desktop Cowork

While Anthropic's Claude Desktop app was initially highly optimized for macOS, Windows is now a fully supported first-class citizen for Claude Cowork. However, configuring local paths, managing shell commands in PowerShell, and working with WSL (Windows Subsystem for Linux) can introduce several Windows-specific friction points.

This guide provides a comprehensive setup walk-through, troubleshooting tips, and integration patterns for Windows power users.

Table of Contents

1. Locating the Windows Config File
2. PowerShell vs. CMD: Environment Configuration
3. Windows-Specific Permission Challenges
4. WSL (Windows Subsystem for Linux) Integration
5. Frequently Asked Questions for Windows Users

Locating the Windows Config File

On macOS, your Claude Desktop config is stored in your Library folder. On Windows, it is located in the user's roaming AppData directory.

The Config File Path

Your claude_desktop_config.json must be created or edited at:

%APPDATA%\Claude\claude_desktop_config.json

Quick Access via Explorer or Terminal

To edit this file, you can quickly open it using the following methods:

• Via Windows Run (Win + R): Copy and paste: notepad %APPDATA%\Claude\claude_desktop_config.json and press Enter.
• Via PowerShell:

  notepad "$env:APPDATA\Claude\claude_desktop_config.json"
  

[!NOTE] If the Claude folder or claude_desktop_config.json file does not exist, you can manually create them in your %APPDATA% folder. Our Config Generator is a great tool to bootstrap this file.

PowerShell vs. CMD: Environment Configuration

When Claude Cowork runs local tools or MCP (Model Context Protocol) servers on Windows, it spawns terminal sessions.

By default, Claude uses the Windows shell environment, which inherits system environment variables. However, node package managers (npx, npm) and python processes must be mapped properly in your environment variables path.

1. The Global Node/NPM Path Issue

If Claude fails to execute an MCP server with exit code 127 (Command Not Found), it usually means Claude cannot resolve your node or npx path.

• Fix: Ensure your Node.js path is added to your User Environment Variables.
• Verify by running where.exe node in command prompt. The output path (e.g., C:\Program Files\nodejs\node.exe) must match your system PATH.

2. Passing Environment Variables in JSON

When defining tools, Windows often requires explicit variables such as USERPROFILE or PATH passed through the config's env block.

{
  "mcpServers": {
    "my-local-tool": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-everything"],
      "env": {
        "PATH": "C:\\Program Files\\nodejs\\;C:\\Windows\\system32",
        "USERPROFILE": "C:\\Users\\YourUsername"
      }
    }
  }
}

Windows-Specific Permission Challenges

Because Cowork operates locally, Windows Defender or your local User Account Control (UAC) might occasionally block file manipulation or script execution.

Windows Defender SmartScreen

When Claude Desktop downloads node modules or writes scripts in the sandbox, Windows Defender might flag them as untrusted files.

• Recommended Action: Create a dedicated workspace directory for Claude (e.g., C:\Users\YourUsername\ClaudeWork). Scope your folder access permissions in Claude Desktop strictly to this directory to avoid full drive scans triggers.
• Execution Policies: If your workflow runs local PowerShell scripts, ensure your system policy allows it by running:

  Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
  

WSL (Windows Subsystem for Linux) Integration

Many developers prefer to run their codebases and tools inside WSL. Since Claude Desktop runs as a native Windows application, it needs helper settings to access WSL directories.

Accessing WSL Files

To grant Claude access to a folder inside WSL, use the network path:

\\wsl$\Ubuntu\home\username\projects\my-project

When Claude asks to select a folder in the graphical user interface, paste the \\wsl$ address into the Windows File Explorer search bar.

Executing Commands in WSL

If your MCP configurations require WSL commands, wrap them using the wsl.exe launcher:

{
  "mcpServers": {
    "wsl-git": {
      "command": "wsl.exe",
      "args": ["git", "status"]
    }
  }
}

WSL vs Native Windows: Which to Choose

One of the first decisions you will face is whether to run Cowork against native Windows paths or through WSL. Both approaches work, but they suit different workflows.

When to Use Native Windows

Native Windows is the right choice when:

• Your project files live on Windows drives (e.g., C:\Users\You\Projects\my-app).
• You use Windows-native tools like Visual Studio, PowerShell scripts, or .NET workflows.
• You want the simplest setup with no additional layers.
• Your MCP servers are Node.js or Python packages installed via Windows npm or pip.

In this mode, Claude Desktop runs as a standard Windows application and accesses files through Windows file paths. No translation layer is needed.

When to Use WSL

WSL is the better choice when:

• Your codebase relies on Linux tooling (bash scripts, Makefiles, Linux-only dependencies).
• You develop in a Linux-like environment and your project expects POSIX paths.
• Your team uses macOS or Linux and you want path compatibility.
• You run Docker containers as part of your development workflow.

With WSL, Claude Desktop still runs as a Windows app, but it accesses files through the \\wsl$\ network path and can execute commands inside the Linux environment using wsl.exe.

Comparison Summary

A Hybrid Approach

Some users keep project files on the Windows filesystem but run build tools inside WSL. This works because WSL can access Windows files through /mnt/c/. For example, a project at C:\Users\You\Projects\my-app is accessible from WSL at /mnt/c/Users/You/Projects/my-app. You can grant Cowork access to the Windows path and use wsl.exe for specific build commands.

The tradeoff is performance: file operations across the WSL/Windows boundary are slower than staying entirely on one side. For intensive builds, keep everything on the same filesystem.

Common Windows Path Issues and Solutions

Windows uses backslashes (\) and drive letters (C:\), which can cause friction in configurations and scripts that expect POSIX-style paths. Here are the most common issues and how to resolve them.

Issue 1: Backslash Escaping in JSON

In JSON configuration files, backslashes must be escaped with a second backslash. A path like C:\Users\You\projects must be written as C:\\Users\\You\\projects in claude_desktop_config.json.

Wrong:

{
  "args": ["C:\Users\You\projects"]
}

Correct:

{
  "args": ["C:\\Users\\You\\projects"]
}

If you see a JSON parse error when Claude Desktop starts, check for unescaped backslashes first. This is the single most common configuration error on Windows.

Issue 2: Spaces in Paths

Paths with spaces (e.g., C:\Program Files\My Project) can break when passed as command arguments. Always quote paths containing spaces:

{
  "args": ["\"C:\\Program Files\\My Project\\build.sh\""]
}

In PowerShell, use single quotes for literal paths:

cd 'C:\Program Files\My Project'

Issue 3: Case Sensitivity Mismatches

Windows is case-insensitive, but Git (especially when configured with core.ignorecase = false) and WSL are case-sensitive. If Claude renames a file from Component.tsx to component.tsx in a Git repo, Windows will not notice the change, but Git will report a modified file.

Solution: Standardize on a naming convention before starting a Cowork session. If you work cross-platform, set Git to be case-sensitive:

git config core.ignorecase false

Issue 4: WSL Path Translation

When Claude needs to access a WSL path from the Windows side, use the \\wsl$ UNC prefix. When a WSL process needs to access a Windows path, use /mnt/c/. Getting these mixed up causes "file not found" errors.

Issue 5: Long Path Limits

Windows has a default 260-character path length limit. Node.js projects with deeply nested node_modules can exceed this. If Claude reports errors writing or reading files deep in a project tree:

Solution: Enable long path support in Windows:

New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force

This requires administrator privileges. Restart Claude Desktop after making this change.

Windows-Specific Configuration

Beyond the config file location, several environment variables and system settings affect how Cowork behaves on Windows.

Environment Variables

Claude Desktop inherits environment variables from the user session. The most important ones to verify:

To check your current environment variables in PowerShell:

$env:PATH -split ';'

To set a persistent environment variable:

[System.Environment]::SetEnvironmentVariable("HOME", "C:\Users\YourUsername", "User")

Restart Claude Desktop after changing environment variables for them to take effect.

PATH Setup for Node.js and Python

If Claude cannot find npx or python, the PATH is usually the culprit.

For Node.js:

1. Confirm Node is installed: where.exe node should return a path.
2. If not, install from nodejs.org and ensure "Add to PATH" is checked during installation.
3. If installed but not found, add the Node.js directory to your User PATH:

   $currentPath = [System.Environment]::GetEnvironmentVariable("PATH", "User")
   [System.Environment]::SetEnvironmentVariable("PATH", "$currentPath;C:\Program Files\nodejs\", "User")
   

For Python:

1. Confirm Python is installed: where.exe python
2. If installed from python.org, ensure "Add Python to PATH" was checked during installation.
3. If missing, add it manually the same way as Node.js above.

Execution Policy

PowerShell's default execution policy may block script-based MCP servers. Set it to allow locally signed scripts:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

This is safe for development machines. RemoteSigned allows local scripts to run without signing but requires downloaded scripts to be signed.

Windows Terminal Setup

A good terminal setup makes working with Cowork and its supporting tools much smoother on Windows.

Recommended: Windows Terminal

Install Windows Terminal from the Microsoft Store. It provides tabs, profiles for PowerShell and WSL, and better rendering than the legacy console.

Recommended profiles to configure:

1. PowerShell 7 (pwsh): The modern PowerShell with better performance and syntax. Install from GitHub releases or via winget install Microsoft.PowerShell.
2. WSL (Ubuntu): Automatically appears if WSL is installed.
3. Command Prompt: Keep as a fallback for tools that require cmd.exe.

Useful Shell Aliases

Add these to your PowerShell profile (notepad $PROFILE) to speed up common Cowork-related tasks:

# Open the Claude config file quickly
function Edit-ClaudeConfig { notepad "$env:APPDATA\Claude\claude_desktop_config.json" }
Set-Alias ccc Edit-ClaudeConfig

# Navigate to your Claude workspace
function Go-ClaudeWork { Set-Location "$env:USERPROFILE\ClaudeWork" }
Set-Alias cdcl Go-ClaudeWork

# Check Claude logs
function Show-ClaudeLogs { Get-Content "$env:APPDATA\Claude\Logs\*.log" -Tail 50 }
Set-Alias cll Show-ClaudeLogs

After saving, reload the profile:

. $PROFILE

Git on Windows

Install Git for Windows from git-scm.com. This provides both the Git CLI and the Git Bash shell. Configure line endings to avoid issues when collaborating with macOS/Linux users:

git config --global core.autocrlf input

This setting converts CRLF to LF on commit and leaves LF as-is on checkout, which is the safest option for cross-platform projects.

Troubleshooting Windows-Specific Errors

Error: "Command not found" (exit code 127)

Cause: Claude cannot locate the executable specified in the MCP server config.

Fix:

1. Run where.exe <command> in a terminal to confirm the executable is on your PATH.
2. If found, copy the full path and use it directly in the config:

   {
     "command": "C:\\Program Files\\nodejs\\npx.cmd",
     "args": ["-y", "@modelcontextprotocol/server-filesystem"]
   }
   

3. Note the .cmd extension. On Windows, npx is actually npx.cmd. Some MCP server configurations fail because they reference npx without the extension. Using the full path with .cmd resolves this.

Error: "EACCES" or "Permission denied"

Cause: Windows file permissions or Defender are blocking access.

Fix:

1. Right-click the folder Claude needs access to, select Properties → Security, and confirm your user account has Full Control.
2. If Windows Defender is blocking script execution, add an exclusion for your workspace folder:

   Add-MpPreference -ExclusionPath "C:\Users\YourUsername\ClaudeWork"
   

3. Run Claude Desktop as your normal user, not as Administrator. Running as admin can cause permission conflicts with user-level file access.

Error: "ENOENT" (File not found) with WSL paths

Cause: The \\wsl$ path is incorrect or WSL is not running.

Fix:

1. Confirm WSL is running: wsl --list --running in PowerShell.
2. If no distros are running, start one: wsl -d Ubuntu.
3. Verify the path by pasting \\wsl$\Ubuntu\home\username into Windows File Explorer. If it opens, the path is correct.

Error: MCP Server Starts but Returns No Data

Cause: The server process starts but cannot communicate with Claude, often due to a port conflict or stdio buffering issue.

Fix:

1. Check the Claude Desktop logs for MCP-related errors. On Windows, logs are in %APPDATA%\Claude\Logs\.
2. Ensure no other process is using the same port (if the MCP server uses TCP).
3. Try adding --verbose to the MCP server args to get more diagnostic output.

Error: Claude Desktop Crashes on Startup

Cause: Usually a malformed claude_desktop_config.json.

Fix:

1. Rename the config file to claude_desktop_config.json.bak to temporarily disable it.
2. Restart Claude Desktop. If it starts successfully, the config file was the problem.
3. Validate your JSON syntax at jsonlint.com.
4. Re-add configurations one MCP server at a time, restarting after each, to identify which entry causes the crash.

FAQ

Does Windows support the "Computer Use" feature?

Yes. The latest Claude Desktop Cowork updates support screen interaction on Windows. However, you must grant administrative or standard app focus permissions if Windows security dialogs intercept focus.

Why does the terminal pop up briefly during tasks?

Claude Desktop launches sub-processes to run script files and command utilities. This is expected behavior on Windows. Ensure your script executions are headless to prevent focus stealing.

Last updated: June 15, 2026

This article is part of CoworkHow.com, an independent resource for Claude Cowork users. We are not affiliated with Anthropic.