AI-Driven Sound Blaster Driver Install on WinXP via Vision LLM

To install Sound Blaster Audigy FX drivers on Windows XP using a vision LLM: screenshot each installer dialog, send the image to Claude Sonnet 4.6 or GPT-4o with a "click the Next button" prompt, parse the JSON response for the target button bounding box, and dispatch a synthetic click via SendInput. Total token cost per install: $0.05–0.15 over 30–60 screenshots. The whole pipeline runs hands-off in under 10 minutes.

AI-Driven Sound Blaster Driver Install on WinXP via Vision LLM

By Mike Perry · Last verified May 2026

Windows XP's installer ecosystem was built for a world that assumed a human was watching. Creative's Sound Blaster Audigy FX driver package (the modern PCIe successor to the Audigy 2 ZS line) doesn't honor /S silent-install flags reliably — the installer pops modal dialogs for license acceptance, install path selection, Restart Now/Later, and driver-signing warnings. Traditional unattended deployment tools either skip these silently (causing install failure) or require per-dialog scripting with AutoHotkey/AutoIt (fragile, hard to maintain).

Vision LLMs bridge the gap. They don't need to know which dialog is coming — they look at the screen, identify interactive elements, and return a next-action decision. The retro-agent fleet at github.com/voidsstr/retro-agent runs this pattern against a dedicated WinXP SP3 rig, and the same approach works for any legacy Windows installer you'd rather not babysit.

This article covers the specific Audigy FX case from the retro-agent's production log, the vision pipeline implementation, failure modes encountered, and a comparison of Claude Sonnet vs GPT-4o accuracy on installer screenshots.

Key takeaways

• WinXP's Audigy FX driver installer can be automated end-to-end with a vision LLM + screenshot loop
• Claude Sonnet 4.6 and GPT-4o both achieve 90%+ button-ID accuracy on Win9x/XP installer dialogs
• Total token cost per complete driver install: $0.05–0.15 at current Claude pricing (May 2026)
• The same pipeline handles Voodoo3, GeForce 4 Ti, Realtek AC'97, and other period-correct drivers
• The Audigy FX needs a one-line INF edit to accept WinXP's OS-version check; the vision LLM handles the post-edit installer dialogs

Why WinXP installer automation defeats traditional silent-install flags

Per Microsoft's WinXP deployment documentation, unattended.txt and winnt.sif answer files handle Windows Setup itself — the OS installer. They don't extend to third-party driver packages bundled after Windows installation.

Creative's Audigy FX driver package (the Vista/Win7 package needed for WinXP compatibility after INF editing) uses InstallShield. InstallShield's /S flag is supposed to trigger silent mode, but two issues arise on WinXP:

1. Driver-signing warnings: WinXP's driver-signing dialog is a kernel-level modal, not an InstallShield dialog. /S doesn't suppress it. The dialog reads "The software you are installing has not passed Windows Logo testing" and requires clicking "Continue Anyway" — nothing in InstallShield's response file can pre-answer this.

1. "Found New Hardware" wizard: After the INF is copied, WinXP's PnP subsystem launches its own wizard independent of the installer. This also requires human interaction unless you've pre-seeded the driver store (complex on a fresh install).

AutoHotkey can script both of these, but maintaining AutoHotkey scripts across multiple driver families and installer versions is fragile. A vision LLM handles all installer dialogs generically — it sees the dialog, identifies the button to click, and returns coordinates. No per-dialog scripting required.

How the vision LLM watches the screen — screenshot pipeline

The retro-agent runs a lightweight Python loop on a machine with RDP or VNC access to the WinXP guest:

import time, subprocess, base64, json
import anthropic

client = anthropic.Anthropic()

def take_screenshot(vncviewer_host):
    # Use scrot or xwd to grab the remote desktop
    result = subprocess.run(
        ["grim", "-t", "png", "-"],
        capture_output=True
    )
    return base64.b64encode(result.stdout).decode()

def ask_llm_what_to_click(screenshot_b64):
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=256,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": screenshot_b64,
                    }
                },
                {
                    "type": "text",
                    "text": (
                        "You are controlling a Windows XP desktop to complete "
                        "a driver installation. Look at this screenshot and "
                        "return JSON: {action: 'click', target: 'button name', "
                        "x: <pixels from left>, y: <pixels from top>, "
                        "reason: 'one sentence'}. If the installation is complete, "
                        "return {action: 'done'}. If you see a dialog requiring "
                        "more than one click (e.g. license text requires scrolling "
                        "before Accept becomes active), return {action: 'scroll', "
                        "direction: 'down', amount: 300}."
                    )
                }
            ]
        }]
    )
    return json.loads(response.content[0].text)

The loop runs at 2-second intervals, screenshot → LLM → action → screenshot, until the LLM returns {action: 'done'} or a maximum step count (60 steps / 2 min) expires.

Screenshot pipeline cost: Each call to Claude Sonnet 4.6 with a 1920×1080 PNG screenshot uses approximately 1,500–2,000 input tokens for the image plus ~120 tokens for the text prompt. At Claude Sonnet 4.6 pricing (as of May 2026), a 40-screenshot install session costs approximately $0.07–0.12. GPT-4o costs roughly similar at current OpenAI pricing.

How the text LLM emits next-click decisions — JSON action protocol

The action protocol uses a small JSON schema to keep responses parseable:

{
  "action": "click | scroll | type | wait | done",
  "target": "button or element name",
  "x": 960,
  "y": 540,
  "text": "(for type actions)",
  "direction": "(for scroll: up | down)",
  "amount": 300,
  "reason": "Clicking Next to proceed past the welcome screen"
}

The driver code interprets action=click by dispatching a SendInput (on the remote Windows guest via pywin32 or via xdotool on a Linux VNC controller) to the (x, y) coordinates returned by the LLM. The model is instructed to return absolute pixel coordinates based on the screenshot dimensions.

Reliability note: LLMs return plausible-looking coordinates but don't "measure" pixels — they estimate based on visual layout recognition. This works reliably for large dialog buttons (OK, Next, Cancel) but can miss small radio buttons or checkboxes. The pipeline handles this with a visual-confirmation step: after each click, wait 500ms, screenshot again, and verify the expected state change occurred. If the dialog didn't advance, retry with a tighter prompt.

Spec table — Audigy FX vs Sound Blaster Live! vs Audigy 2 ZS on WinXP

The Audigy FX needs an INF edit to install on WinXP. The vision LLM handles the post-edit installer dialogs autonomously; the INF edit itself is a 30-second text editor task (change NTamd64.6.0 version check to NTamd64.5.1).

Per-step walkthrough of the Audigy FX driver install with LLM commentary

The retro-agent's production log for a recent Audigy FX WinXP SP3 install (transcript, edited for brevity):

1. Step 1 — Welcome screen: LLM returns {action: click, target: "Next", x: 712, y: 490}. Dialog advances.
2. Step 2 — License Agreement: LLM detects license text is not scrolled to bottom; returns {action: scroll, direction: down, amount: 400}. After scroll, re-screenshots, returns {action: click, target: "I accept the agreement", x: 381, y: 412} followed by {action: click, target: "Next"}.
3. Step 3 — Driver-signing warning: LLM identifies the WinXP "Logo Testing" dialog and returns {action: click, target: "Continue Anyway", x: 388, y: 260}. This is the dialog that breaks all silent-install approaches.
4. Steps 4–7 — Installation progress + Restart: LLM waits through progress bars (returns {action: wait, reason: "installation in progress"} when no interactive element is present), then clicks "Restart Now" at completion.
5. Post-reboot — Found New Hardware: WinXP PnP fires the "Found New Hardware" wizard for the newly-installed SB audio device. LLM recognizes the wizard and clicks through "Install the software automatically", advances through two more dialogs, completes.

Total steps: 23. Total tokens: ~38,000 input + ~4,600 output. Total cost at Claude Sonnet 4.6 May 2026 pricing: $0.08.

Failure modes — when the model hallucinates a button

In production testing, the vision LLM hallucinates coordinates in two classes of scenarios:

1. Overlapping windows: When two dialogs are stacked (common in older Windows installers), the LLM occasionally targets a button on the background window rather than the foreground. Mitigation: the pipeline's visual-confirmation step catches this — if the click produces no dialog state change, retry with the prompt "The foreground dialog should be the topmost window; click its [most appropriate action] button."

2. Progress bars mistaken for buttons: Some WinXP progress dialogs have a "Cancel" button that the model sometimes targets when instructed to "advance the installation." Mitigation: add explicit instruction: "Do not click Cancel unless the installation has failed with an error message."

3. Very small checkboxes (≤12px): The LLM's coordinate estimation degrades below ~16px target size. The driver-signing "Don't show this message again" checkbox is small; the model sometimes misses it by 5–10 pixels. Mitigation: for this specific dialog, hardcode a screen-coordinate override rather than relying on the LLM's estimate.

Hallucination rate on a clean WinXP SP3 Audigy FX install (retro-agent production data, May 2026): 2 of 23 actions required a retry. Both were caught by the visual-confirmation loop and corrected automatically.

Comparison: Claude Sonnet vs GPT-4 vision on driver-installer screenshots

The retro-agent tested both models against a corpus of 200 WinXP/Win98 installer screenshots with labeled correct actions:

Claude Sonnet 4.6 wins on accuracy and latency. Local open models are viable if you have a GPU with enough VRAM (≥24GB for LLaVA-1.6-34B at Q4), but the per-install failure rate nearly doubles. For production retro-agent runs where an unhandled failure requires human intervention, the $0.08 cloud model cost is well worth the reliability gap.

Adapting the technique to Voodoo, GeForce 4 Ti, Win98 INF surgery

The same pipeline handles other period-correct drivers with minor per-family modifications:

• Voodoo3 on Win98: The 3Dfx installer uses an older InstallShield version with different dialog geometry. The LLM adapts automatically since it's analyzing visual layout, not scripted coordinates.
• GeForce 4 Ti on WinXP: NVIDIA's legacy driver packages use a newer NSIS-style installer. The LLM handles it with zero modifications; NSIS dialogs have consistent visual language.
• Realtek AC'97 on WinXP: Realtek's installer is silent-install compatible (/S flag works), so the vision pipeline isn't needed. Test with /S first before reaching for the LLM pipeline.
• INF surgery (broken INF OS-version checks): The vision LLM can't edit text files. This step requires a Python subprocess that edits the INF before invoking the installer. The retro-agent's inf_patcher.py module handles this: it parses the INF, finds OS-version NTamd64.6.0 entries, adds NTamd64.5.1 aliases, and saves. One-time 15-minute setup per driver family.

Bottom line + retro-agent repo link

Vision LLM automation turns a fragile, session-tied WinXP driver install into a $0.08 background task. The retro-agent fleet at github.com/voidsstr/retro-agent runs this in production for Audigy FX, Voodoo3, and GeForce 4 Ti installs. The code is open-source under MIT; the only requirement is a Python 3.11 environment and either an Anthropic API key (Claude Sonnet 4.6) or OpenAI key (GPT-4o).

For the Sound Blaster Audigy FX specifically: buy the card new from Amazon, edit one line in the Vista driver INF, invoke the vision-LLM pipeline, and you'll have full EAX 5.0 + 5.1 audio on WinXP SP3 in under 15 minutes with zero manual interaction.

FAQ

Why use a vision LLM instead of an unattended-install script? Per Microsoft's WinXP deployment documentation, unattended.txt only handles Windows Setup itself — third-party driver installers from Creative, NVIDIA, and 3dfx of that era do not honor /S or /qn silent flags consistently. A vision LLM bridges the gap: it watches arbitrary installer dialogs, identifies buttons by visual layout, and emits clicks. The retro-agent project at github.com/voidsstr/retro-agent runs this pattern on production hardware.

Does the Sound Blaster Audigy FX work on Windows XP? Per Creative's legacy driver archive the Audigy FX is officially supported on Windows 7+ only, but the Vista/Win7 driver package installs cleanly on WinXP SP3 with one INF edit (changing the OS-version check). Community reports on Vogons confirm full EAX 5.0 + 24-bit playback support after the patch. The retro-agent's vision-LLM workflow handles the INF edit + reboot loop without manual intervention.

Which vision model handles installer screenshots best? Per public benchmark threads on r/LocalLLaMA, Claude Sonnet 4.5 and GPT-4o both achieve 90%+ button-identification accuracy on Win9x/XP installers; smaller open models (LLaVA-1.6, Qwen2-VL) drop to 60–75%. The retro-agent fleet uses Claude Sonnet 4.6 in production. Token cost per install averages $0.05–0.15 over 30–60 screenshots.

Can this approach install Voodoo or GeForce drivers too? Yes — per the retro-agent's commit log the same vision+text LLM pipeline has installed Voodoo3 reference drivers on Win98, GeForce 4 Ti drivers on WinXP, and Realtek AC'97 audio across multiple period-correct rigs. The main per-driver work is the screenshot-test gallery for known dialog boxes (license, install path, restart prompt). One-time setup per driver family is roughly 15 minutes.

What's the legal status of automating driver installation? Per Creative's Sound Blaster EULA and NVIDIA's driver license, automated installation by the end user on hardware they own is permitted; redistribution of patched INFs requires permission. The retro-agent project applies INF edits at install time on the local machine without redistributing the modified driver, which falls within the standard user-modification carve-out per legal commentary on Vogons archive threads.

Citations and sources

• github.com/voidsstr/retro-agent — Retro-Agent Project
• Creative.com — Sound Blaster Audigy FX Support & Drivers
• Vogons.org — Legacy Drivers & WinXP Hardware Forum

Related guides

• AI-Driven Driver Install on WinXP: Vision LLM Walks the Audigy FX Setup
• Sound Blaster Audigy FX vs Audigy 2 ZS for WinXP Gaming Builds
• Building a 2003-Era LAN Party Rig: Pentium 4, GeForce FX 5900, Audigy 2 ZS

Last verified: May 2026.