Background computer use on Windows for Claude Code: test a GUI app in a separate Windows session

Can Claude Code test a Windows desktop app without taking over your mouse, keyboard and screen? Yes, in our test: on 15 November 2026, with Anode 0.11.4's MCP server, headless Claude Code 2.1.325 built a small Windows Forms app, started it in Anode's hidden Windows session, found a wrong total by entering the spec's example and pressing the app's button, fixed the source, rebuilt and re-checked it in 5 of 6 runs (4 of 4 on Sonnet 5.5, 1 of 2 on Haiku 5.5); the completed runs took 45 to 141 s, and the one run that stopped (Haiku) was refused Anode's window-closing tool by our own permission list and didn't close the app another way. In 8,491 samples taken about every 50 ms over 437 s on the PC's own desktop, the app and Anode never had the foreground, the app never had a window or a process there (its process ran in session 2 only), and no pointer move happened without input in that session; the desktop was in use during three runs, and in the three where nobody touched it the pointer never moved at all. This needs a tool because, by their docs read on 16 November 2026, Claude Code's own computer use is not available on Windows, Claude Desktop's computer use "runs on your actual desktop", and the background mode that leaves your pointer and keyboard alone is documented for macOS only; open request #99740 asks Claude Code for an "isolated GUI testing mode on Windows".

We make Anode. Claude Code is Anthropic's; we are not affiliated with Anthropic. Our numbers come from six recorded runs whose data is linked under Method. Everything about Claude Code, Claude Desktop, Codex and the other tools comes from their own docs and issues, read on 15 November 2026, re-read on 16 November and linked; we did not run those features. If we got something wrong, open an issue and we will correct it.

Last checked: 16 November 2026 (runs: 15 November) · Claude Code 2.1.325 · Anode 0.11.4 · Windows 11 Pro 25H2 (build 26200) · Next check by 16 December 2026, or sooner when Claude Code or Anode changes how computer use works on Windows.

The short answer

What Claude Code and Codex do on Windows today

From their docs and issues, read on 15 November 2026 and again on 16 November; we ran none of these features.

Microsoft documents a child session as a loopback Remote Desktop session tied to the user's own session, available since Windows 8 and Windows Server 2012, one active per system (child sessions). Anode's README says its seat is a child session for your own account, created by Windows' loopback Remote Desktop feature. Anode is a separate MCP server that Claude Code calls, not the built-in mode #99740 asks Anthropic for.

Set it up

From Anode 0.11.4's README. You need Windows 10 or 11 Pro, Enterprise or Education (not Home) on x64, and administrator rights once, for anode setup. On a managed work PC, a policy that blocks unsigned programs or keeps Remote Desktop off will stop it. Anode's own walk-through is Test your desktop app with Claude Code.

1. Install, set up and register

In PowerShell, run the first line, then open a new terminal for the next two:

iwr -UseBasicParsing https://github.com/skulitom/Anode/releases/latest/download/install.ps1 -OutFile install.ps1; powershell -NoProfile -ExecutionPolicy Bypass -File .\install.ps1
anode setup | Out-Host       # in a NEW terminal: one administrator prompt, once per machine
anode configure | Out-Host   # registers Anode with the Claude Code and/or Codex CLIs on your PATH

The PC we measured on was already set up and signed in, so we did not re-run these steps today. Our runs also did not use anode configure: they gave Claude Code the server through --mcp-config (mcp-config.json) in a fresh, empty config folder, without Anode's anode-desktop skill and with no timeout setting.

2. Ask for the test

The prompt we gave Claude Code, word for word (prompt.txt):

You are working on TipCalc, a small Windows Forms app in the TipCalc folder (its spec is TipCalc/SPEC.txt). Check that the app does what the spec says by using it the way a user would, in Anode's background seat, not on my desktop.

  1. Build it with exactly this command: dotnet build TipCalc/TipCalc.csproj -c Release
  2. Start the built TipCalc.exe in the seat with Anode, and test the spec's example by typing into the app and pressing its button.
  3. If the app shows the wrong result, find the cause in the source, fix it, close the app, rebuild with the same command, start it again in the seat and test the same example again.
  4. Leave the app open showing the final result. Then report what the app showed before and after, what you changed, and each Anode tool you used.

Use only Anode's tools on the app's window. Keep the viewer hidden, don't touch any other window in the seat, and don't use my desktop.

3. Allow the tools it needs

Our allow-list was Read, Edit, Glob, Grep, Bash(dotnet build:*) and 15 of Anode's tools: anode_guide, seat_status, seat_lease, seat_capabilities, seat_run, seat_windows, seat_observe, seat_element, seat_wait, seat_screenshot, seat_click, seat_type, seat_key, seat_processes and seat_kill_process; runs 5 and 6 added seat_window. With nobody to ask, headless Claude Code refused every call that needed approval (12 in all). Two lessons:

What we measured

The app: TipCalc, a Windows Forms app on .NET 10 with two text boxes ("Bill amount", "Tip percent"), a Calculate button and a result label, all with accessible names. Its spec gives one example: bill 80 and tip 15 should show "Total: 92.00". We planted one bug: TipMath.Total returned bill + tipPercent, so the example showed "Total: 95.00".

The runs: six headless claude -p jobs on 15 November 2026, 15:34 to 15:44 UTC, each in a fresh copy of the app, with the prompt and allow-list above. Four ran on Sonnet 5.5 (claude-sonnet-5-5), two on Haiku 5.5 (claude-haiku-5-5). After each job we read the app's result label ourselves in the seat, then closed the app (results.json). The four Sonnet runs typed the numbers with seat_type; the two Haiku runs set the boxes' values through accessibility (seat_element). Calculate was pressed with a click (seat_click, runs 1, 3 and 6) or an accessibility invoke (seat_element, runs 2, 4 and 5).

RunModelPermission listFinished the loop?TimeTool calls (Anode's)Calls not okList-price cost (USD)What we read in the seat afterwards
1Sonnet 5.5without seat_windowYes54.8 s26 (16)2, both refused by our list0.1814Total: 92.00
2Sonnet 5.5without seat_windowYes140.8 s (model time 41.6 s; it waited for the seat)29 (19)4: 3 refused by our list, 1 seat wait that ran out0.1744Total: 92.00
3Sonnet 5.5without seat_windowYes53.2 s26 (17)2, both refused by our list0.1593Total: 92.00
4Haiku 5.5without seat_windowNo: it fixed the source, but the rebuild failed54.3 s22 (16)4: 2 refused by our list, 1 mistyped observation id, 1 failed rebuild0.0158Total: 95.00 (the first, unfixed build was still open)
5Haiku 5.5with seat_windowYes58.8 s35 (24)2, both refused by our list0.0184Total: 92.00
6Sonnet 5.5with seat_windowYes45.3 s22 (13)1, refused by our list0.1373Total: 92.00
All5 of 6160 (105)150.6866Total: 92.00 in 5 of 6

Every run made the same one-line fix, return bill + bill * tipPercent / 100; (run 4 wrote 100m, the same value). Of the 15 calls that weren't ok, 12 were refused by our permission list; 1 was run 2's first request for the seat, which our own session still held after taking the screenshot below and closing run 1's app (Anode put the agent first in line, and its second request got the seat); 1 was an observation id that Anode didn't recognise because the model had mistyped it (it resent the right one); and 1 was run 4's failed rebuild. Costs are Claude Code's own list-price estimate for these tiny runs.

Run 6, call by call

Sonnet 5.5, 22 calls, 13 of them Anode's, 45.3 s (run6.agent.json):

  1. Loaded Anode's tool definitions (Claude Code's ToolSearch), read the spec and listed the source files.
  2. Tried one compound shell command, which the allow-list refused.
  3. Built with dotnet build TipCalc/TipCalc.csproj -c Release in its own shell, and read TipMath.cs and MainForm.cs.
  4. seat_run started TipCalc.exe in the seat, seat_windows found its window and seat_observe read its controls, without a screenshot.
  5. seat_type typed 80, Tab, 15; seat_click pressed Calculate; seat_observe read the result: "Total: 95.00".
  6. Edited TipMath.cs.
  7. seat_window closed the app, and seat_processes showed it had exited.
  8. Rebuilt with the same command.
  9. seat_run, seat_windows, seat_type and seat_click again, then seat_wait until the result label contained "Total: 92.00".
The TipCalc window inside the seat: Bill amount 80, Tip percent 15, a Calculate button, and the result line Total: 92.00.
TipCalc in the seat after run 1, captured inside the seat by our own session and cropped to the window, with its four corners cut to transparent so nothing behind the window shows.

What the PC's own desktop saw

parent_watch.py ran on the PC's own desktop (session 1) from 2 seconds before each job until it ended. About every 50 ms (it sleeps 50 ms between samples) it read the pointer position, which process owned the foreground window (compared only with TipCalc's and Anode's names) and the session's last-input clock; once a second it listed the sessions holding a TipCalc.exe process and counted that app's windows on this desktop. A pointer move counts as "without input" when the clock shows no input in the session since the previous sample, that is, a program moved the pointer. As a positive control, control_run.py ran the watcher inside the seat and moved the pointer there 6 times with SetCursorPos: it counted 6 of 6, and Anode's pointer guard count went from 9 to 15 with 0 forwarded (control-result.txt).

RunSamplesSecondsSamples with new inputPointer positionsForeground changesForeground samples: app or AnodePointer moves without inputSessions holding the app's processApp windows on this desktopPointer guard count, before → after
11,16560.1137293400207 → 8
22,833145.8713000208 → 8
31,12858.101000208 → 9
41,15059.33864000209 → 9
51,23963.801000209 → 9
697650.201000209 → 9
All8,491437.3 (sum of the rows)1824002 only07 → 9, 0 forwarded

Anode's pointer guard counts the seat's pointer moves it kept off your own pointer: Windows' Remote Desktop control in Anode's viewer would otherwise copy them onto yours while your pointer is over the viewer's rectangle (Anode's troubleshooting). Its count rose by 1 in runs 1 and 3 and not in run 6, though all three clicked with seat_click (two or three times each); we don't know which seat event each count was. Its forwarded count stayed at 0 (run-notes.txt; per run: 1, 2, 3, 4, 5, 6).

What this doesn't show

With Codex instead

anode configure also registers Anode with the Codex CLI when it is on your PATH, including the 420-second tool timeout that lets a cold seat finish signing in (README; connecting Codex). Codex's own computer use on Windows works on your active desktop and takes over the pointer and foreground, by OpenAI's docs. We didn't run Codex for this page.

Where Anode doesn't help

Sources: Anode 0.11.4's README, SECURITY.md and USAGE.md. The full list, and a comparison with Codex, Claude, GitHub Copilot's app, agent-desktop and Cua Driver, is in AI computer use on Windows in the background.

When to use something else

From each tool's docs or issues, read on 16 November 2026, not run by us.

Claude on macOS

On macOS 15 or later, the Claude Desktop app's computer use (Cowork and its Code tab) works in background windows by default and leaves your pointer and keyboard alone (help centre). The CLI's own computer use hides your other apps while it works and needs an interactive session, so it isn't available with claude -p (its docs).

Claude's own computer use on Windows, while you watch

For a short task you want to see happen and can step away for: Claude Desktop's computer use runs on your actual desktop, hides your other windows while it works, and is a research preview on Pro, Max and Ultra plans (desktop docs). Claude Code's CLI has no computer use on Windows.

Windows Sandbox or a virtual machine

When the agent's work must not reach your files, accounts or network. Windows Sandbox comes with Pro, Enterprise and Education, not Home; closing it deletes everything in it, software installed on your PC isn't available inside it, and only one runs at a time (Microsoft). Hyper-V comes with Windows 11 Pro, Enterprise and Education (Microsoft). Either way you set up your app's runtime and tools in a second Windows, which #99740 counts as more overhead. OpenAI suggests a Windows virtual machine for Codex's computer use.

Tools that work inside your own session

They send accessibility calls or window messages to one app's window in your own session, so they can reach windows you already have open, without a second session. agent-desktop (1.3.1, 13 November; Windows 10 1809 or later, x64 or ARM64): its README says its ref actions use the accessibility API without moving the pointer or taking focus; typing needs --headed (its Windows page), and an open issue (#567) reports its actions bringing background windows forward. Cua Driver (0.52.6, 16 November): its docs say it doesn't raise the window, move the real pointer or switch the frontmost app, sending window messages to the target window and reporting background_unavailable when it can't; its sessions still share one screen, keyboard and focus. #99740 notes that window-scoped tools don't give complete desktop semantics to apps with several windows.

Headless tests

When the check needs no desktop. This page's planted bug sits in one function, so a unit test would find it without any window; a GUI loop earns its keep when the fault is in what the window shows or how it responds.

A headed browser

A pull request for a Playwright option to stop a headed Chromium's new pages taking the operating system's focus (#41282) was closed unmerged on 15 June 2026, and the follow-up issue (#41306) was closed as not planned on 31 October 2026. Run browser tests headless when you can. Anode's README says it also runs headed browsers in the seat; we didn't measure that here.

Method: how to repeat it

Searches this page answers

Run together on 15 November 2026 at about 15:31 UTC, with a web search tool on a US index (raw results). "Our site" means skulitom.github.io/Anode or github.com/skulitom/Anode. Three of the results named below were on claudeissues.com, a site that mirrors GitHub issues; we couldn't open it from our network on 16 November, so it is named here and the link goes to the issue itself.