Controlling Windows 98 and XP PCs with AI agents — the retro-agent project

One of the strangest and most delightful uses of AI agents in 2026: having Claude manage a fleet of Windows 98 and Windows XP machines. That's exactly what the open-source retro-agent project does.

The problem

Retro PC enthusiasts maintain fleets of period-correct machines — Voodoo5 Win98 boxes, Pentium III XP rigs, Athlon 1GHz benchmark rigs. Installing drivers, swapping games, benchmarking video cards, and troubleshooting DLL errors is tedious manual work across machines that lack modern remote management.

The solution

The retro-agent is a small (< 1MB) native Windows agent written in C. It:

• Listens on TCP ports 9897 + 9898
• Accepts a simple text protocol (SYSINFO, EXEC, LAUNCH, UPLOAD, DOWNLOAD, PROCLIST, UICLICK, UIKEY, SCREENSHOT, REGREAD, REGWRITE, …)
• Works on Win95/98/Me/2000/XP/7/10/11
• Ships as a single .exe — no installer, no .NET, no runtime deps

Claude (via the Anthropic API or Claude Code) connects over TCP, sends commands, and reads responses. That's it.

A typical session

From Claude Code, running against a retro-agent fleet:

from shared.retro_protocol import RetroConnection

c = RetroConnection('192.168.1.124', 9898)
await c.connect('retro-agent-secret')

# Diagnose a black-screen issue
status, sysinfo = await c.send_command('SYSINFO')
status, video   = await c.send_command('VIDEODIAG')
status, display = await c.send_command('DISPLAYCFG')

# If video driver is wrong, fix it
await c.send_command('REGWRITE HKLM\\System\\...\\Display Mode 1024x768x32')
await c.send_command('REBOOT')

Claude can interpret the SYSINFO JSON, recognize a missing display driver, upload the correct INF file via UPLOAD, trigger regedit.exe to apply it, and reboot. All autonomous.

What makes this work on 30-year-old OSes

Win98 has unique memory management bugs — over 512MB RAM without a vcache limit crashes VxDs. The agent's SYSFIX command applies the fix automatically.

Win98 autologon needs specific registry keys under HKLM\Network\Logon that modern tooling doesn't touch. The agent handles this.

No asyncio — the agent uses Win32 threads on NT kernels and a cooperative multiplex loop on Win9x (because GCC __thread TLS vars don't initialize on Win98).

The project's README documents all these quirks — read it as a time capsule of late-90s Windows internals.

Building your own

The protocol is trivial — a 4-byte length prefix plus ASCII command text. You could reimplement the agent in Rust, Go, or Python+PyInstaller. The value isn't the code; it's the documented catalog of Windows 9x/XP quirks the project has accumulated.

Beyond diagnostics: game automation

The retro-agent's UICLICK / UIKEY / SCREENSHOT commands enable GUI automation. Examples from the repo:

• Launch MechWarrior 2 on Win98, click through the splash screen, benchmark, screenshot, report FPS
• Install a DOS game via its DOS installer (start DOSBox inside Win98, navigate with arrow keys, complete install)
• Run the NVIDIA Display Properties control panel to apply 1600x1200@85Hz because ChangeDisplaySettings crashes Win98 with NVIDIA drivers

Claude reasons about screenshots (via Claude Vision), picks the next click, iterates. It works.

Related open-source bits

• retro-benchmark — a synthetic benchmark binary that runs inside Win98/XP and reports FPS
• NSC Dashboard — a React + FastAPI control plane that wraps the retro-agent fleet, with live video streaming of each machine
• Game library scanner — ingests a 4TB SMB share of period games and categorizes them

Why does this matter for AI-adjacent enthusiasts?

Retro computing is a perfect sandbox for multi-agent orchestration. The machines are stateful, network-exposed, full of quirks, and failure modes are cheap (reboot takes 30 seconds). If you want to learn how to build a robust agent system, start here before trying to automate your actual production infrastructure.

Plus: having Claude install a 1998 Voodoo driver on an Athlon 1GHz machine while you read your mail is the most satisfying thing you'll do this month.

Related

• AI Agent coordination with LangGraph →
• NSC Dashboard architecture →

Why this exists

Retro-PC fleets (Win98 / XP / 2000) don't come with modern remote management. RDP is flaky on 9x; SSH doesn't exist natively; even getting screenshots off a Voodoo5 Win98 box requires workarounds. The retro-agent fills that gap — a 1 MB native Windows binary that speaks a simple text protocol over TCP.

Once a fleet is wrapped in retro-agents, every diagnostic / deployment task that used to mean "go find the keyboard attached to the Sony CRT in the basement" becomes a one-line API call.

What the retro-agent can do

Full command reference in the retro-agent GitHub repo. The high-level categories:

Agent architecture

The agent is stateless per-connection — every TCP connection is authenticated once (retro-agent-secret), then commands flow text-in / response-out. Responses are either ASCII text or framed binary (screenshots, file uploads). It listens on two ports (9897 for dashboard, 9898 for scripts) to avoid contention.

Two build variants:

• retro_agent.exe — native Windows. C, statically linked, ~1 MB. Runs on 95/98/Me/2000/XP/7/10/11.
• retro_agent_linux — equivalent Linux build (Python + PyInstaller). For the occasional Linux retro box.

Key design decisions (all informed by actual Win9x failures we hit):

• Multiplex (single-threaded) mode on Win9x. GCC __thread TLS breaks on Win98's CreateThread; multiplex mode avoids it.
• Skip SO_RCVTIMEO on Win9x. setsockopt(SO_RCVTIMEO) corrupts client sockets on Win98. Detected via VER_PLATFORM_WIN32_NT and skipped.
• Use ExitWindowsEx with COMMAND.COM killed first. Lingering console processes block Win98 shutdown; killing them is required for reliable REBOOT.
• No SYSTEM service install on 9x. 9x doesn't have services. Autostart via Run registry key.

How we tested and compared

This architecture is deployed across four retro PCs on the SpecPicks fleet:

The agent has been in production across this fleet for three years; numbers in this article come from actual operational experience. Patterns cross-reference the Claude Code best practices (retro-agent is "Claude Code for retro PCs" structurally) and community retro-computing patterns on VOGONS.

The chat-proxy layer

The coolest piece: retro_chat.exe runs on a retro machine and gives the user a ChatGPT-like experience where the "backend" is Claude Code on the dev box. Architecture:

1. User types in retro_chat.exe on a Voodoo5 Win98 box.
2. Chat client pushes the prompt to the local retro-agent via PROMPT_PUSH.
3. A persistent daemon (retro_chat_daemon.py) on the dev box long-polls PROMPT_WAIT, picks up the prompt.
4. Daemon writes /tmp/retro-chat/inbox/<host>-<seq>.json.
5. A background Claude Code subagent watches the inbox, writes responses to /tmp/retro-chat/outbox/.
6. Daemon streams responses back via LOG_APPEND to the originating agent.
7. Chat client polls LOG_READ [offset] and renders.

Net effect: Claude Opus answering questions typed on a 1998 beige-box Pentium II running Windows 98.

Real use cases (not hypothetical)

• Driver install on a fresh Win98 box. Upload driver → launch installer → walk through wizard via UICLICK / UIKEY → reboot → verify via REGREAD HKLM\\System\\CurrentControlSet\\Services\\Class\\Display\\0000 DriverDesc. No human hands on the keyboard.
• Benchmark runs. Deploy retro_bench.exe via UPLOAD → LAUNCH → screenshot result → POST result to dashboard.
• XP activation recovery. XPACTIVATE apply runs UMSKT-based phone activation automated. No more "stuck at login screen" visits to the basement.
• Game installation sweep. Scanner finds games on SMB share → orchestrator pushes installer → LLM-vision-guided walkthrough handles the old DOS installer UI.
• Wake-on-LAN fleet wake-up. wake_on_lan.py --all --wait wakes four retro boxes, waits for each agent to come online, ready for the day's benchmarking.

Frequently asked questions

Does this work on Windows 95?

Yes in principle, but we haven't tested on 95 in over a year. 98 SE is our oldest supported OS. If you try 95, expect to recompile the agent with older-SDK-compatible toolchain.

What about DOS?

No — the agent relies on Win32 APIs (Winsock, Registry, CreateProcess). A DOS agent would need to be an entirely different binary. For DOS diagnostics we use VOGONS-style manual workflows.

Is the protocol secure?

Shared-secret auth over plain TCP on a trusted LAN. Don't expose the agent port to the internet — full stop. For remote access, tunnel via WireGuard or SSH port-forward.

Can I use this on my own retro fleet?

Yes — the retro-agent project is MIT-licensed. Binary ships on the SpecPicks SMB share for our fleet; you'd build your own.

Does it work alongside other remote tools (VNC, RDP)?

Yes — the agent listens on 9898/9897 and doesn't interfere with 3389 (RDP) or 5900 (VNC). Common pattern: VNC for interactive troubleshooting, retro-agent for scripted/automated tasks.

Sources

1. retro-agent GitHub repository — source, full command reference, build notes.
2. Anthropic — Claude Code best practices — agentic workflow patterns the retro-agent follows.
3. VOGONS retro-PC community forums — reference for retro-PC driver and Win9x troubleshooting.
4. NVIDIA UNIX Legacy GPU Driver archive — authoritative legacy-GPU driver versioning.

Related guides

• Voodoo5 5500 tuning guide — 2026 edition
• GeForce4 Ti 4600 tuning guide
• Building a period-correct Windows 98 gaming rig
• NSC Dashboard — multi-agent orchestration stack

---

— SpecPicks Editorial · Last verified 2026-04-21