Local AI Builds Recall and Copilot+ Alternatives on an Nvidia RTX Spark Laptop

The model built a tray app that imitates Recall, Click to Do, Live Captions and natural-language file search. It is one writer's experiment on one machine, not a benchmark and not a Microsoft feature. It is still a useful look at what a high-memory Windows on Arm laptop can do with local AI, and where autonomous coding agents go wrong.

Certified, but missing the features​

Microsoft's May 31 announcement said RTX Spark is a Copilot+ PC certified chip, but you won't find any Copilot+ PC features at launch, according to Windows Central's review. The same review says Microsoft is working with NVIDIA to bring Recall, Click To Do and on-device Semantic Search to the platform in the coming months, running on a 50 TOPS NPU.

XDA's separate NPU investigation reports a 55 TOPS accelerator, per ComputerBase, intended solely for Copilot+ features. It also says third-party software can't access it through the normal interfaces. That is why the NPU is quoted at 50 or 55 TOPS depending on the source, and why the homemade app runs its small models on the CPU instead.

For comparison, Microsoft's own Recall support page lists these requirements:

• At least 50 GB of free storage to enable it.
• Device Encryption or BitLocker.
• Windows Hello Enhanced Sign-in Security with at least one biometric sign-in option.

XDA doesn't say which gap, hardware or software, is holding Recall back on this laptop.

The setup​

The author ran Qwen 3.8 Flash Next, which he describes as a 125-billion-parameter mixture-of-experts model with six billion active parameters. He used Unsloth's IQ4_XS quant in llama.cpp, with a 262K context window, vision support and an MTP draft model for speculative decoding. Generation ran at roughly 45 to 50 tokens per second.

The agent was Pi, a minimal coding agent that gives the model a PowerShell tool and file editing. The rules in the prompt were:

• Write software for the same laptop the model is running on.
• Don't touch the llama.cpp server.
• Don't load a copy of the model.
• Don't do anything that needs administrator rights.
• Run offline and listen only on localhost.
• Commit to git, keep a build log and document decisions.

One accident shaped the run. The author misconfigured the SearXNG instance meant to give the model web search, and he noticed about an hour in. The model could still download packages through PowerShell. But it had to guess documentation URLs, which produced many 404s. Every workaround came from its own training or from experimenting on the machine.

What Spark Copilot does​

• Recall-style timeline: It captures the screen every 10 seconds or when the active window changes, and discards near-duplicates. It runs OCR and stores the text with an embedding in an encrypted database. The author searched for "that spreadsheet with Dublin rents" and got back both the file and the screenshot. It skips password managers, credential prompts and private browsing windows, and has a pause hotkey.
• Click to Do-style actions: You drag a box on screen and can summarise, explain, rewrite, extract a table as CSV, ask questions, describe an image, or search the Recall store.
• Live Captions: It transcribes system audio with Nvidia's Parakeet and translates from English into Spanish, German or French. Captions appear in the app's dashboard, not in an always-on-top bar.
• File search: It indexes folders you choose and answers questions with citations to the source documents.

Always-on work (OCR, speech recognition, embeddings, translation) runs on small CPU models. The big Qwen model is called only on demand, with a simple local fallback if the llama.cpp server times out.

How the model worked around Windows on Arm​

The agent queried PyPI for 100 Python packages to see which had Windows Arm64 wheels. XDA reports no Arm64 builds for PyTorch, OpenCV, CTranslate2, sqlite-vec, PyAudio or the DirectML build of ONNX Runtime. The current cryptography release had none either. The model missed that an older cryptography release did have one. Treat this as a snapshot of one agent's check, not a current compatibility list.

• OCR: The model dropped a plan to rebuild PaddleOCR in NumPy and used the built-in Windows OCR API. XDA says it read a 2880 × 1800 screenshot in 92 milliseconds with no model download. Microsoft's documentation adds a caveat. APIs in that namespace are only supported for desktop apps with package identity, meaning apps run from an MSIX package. That could trip up developers trying to copy the approach, and XDA doesn't say how its app handled it.
• Speech: It switched to sherpa-onnx, which has Arm64 wheels. XDA says the INT8 Parakeet TDT 0.6B model ran about 40 times real time on four CPU threads.
• System audio capture: PyAudioWPatch has no Arm64 build, and sounddevice didn't expose loopback devices. The model wrote its own COM interface. Its first GUIDs were wrong and it declared IAudioCaptureClient::GetBuffer with four parameters instead of five, which caused an access violation. It fixed both by reading the source of the pycaw and soundcard packages.

The model then wrote in its notes that this Windows build had added an undocumented parameter. XDA says Microsoft has documented all five parameters since Windows Vista. The code was right and the explanation was wrong. That is the most useful warning in the story for anyone reading agent-generated build notes.

What the soak test caught​

About three hours in, the features passed their own tests. The model then ran everything together for a long soak test, and it turned up the serious bugs:

• Reasoning ate the token budget. Recall search expanded queries with the big model but capped output at 40 tokens. A reasoning model used all of them thinking, so the LLM path silently failed and a keyword fallback hid it. Searches took about 25 seconds. The model found that thinking: false was ignored while enable_thinking: false worked, and search dropped to about half a second.
• Capture stopped in the tray. The app's own hidden host window kept taking focus. Its privacy rules forbid capturing its own windows, so frames came out black. A pixel-size threshold failed at the display's 267% scaling. The working fix exempted the window by name and stopped it taking focus.
• Data loss on restart. An open SQLite transaction meant rows added since startup were missing from the encrypted snapshot. The fix was a commit before saving, plus tests that reopen the database from disk.
• A wrong diagnosis. The same transaction broke full-text search after restart. The model first blamed SQLite and added an index rebuild, then found the real cause and never revisited its first theory. The rebuild is harmless but wasn't needed for this bug.
• Junk in the index. Indexing the Documents folder showed that 45% of 7,524 documents were tokenizer and config files from downloaded models. The model filtered them out and moved its own test data into separate databases.

Run statistics​

All figures below are XDA's, not independently verified.

Most of the time went to prefill. Some test runs invalidated the llama.cpp cache, which forced a full reprocess near the top of the context window. Ten requests took over five minutes each, and the longest took about eight. Model requests accounted for about four and a half hours.

How far to trust it​

XDA calls this a first iteration, and the model's own report lists the gaps:

• English-only OCR and speech recognition.
• Translation only from English into three languages.
• Manual file indexing.
• Excel and PowerPoint files skipped.
• Captions only in the dashboard.
• Some errors hidden rather than shown to the user.
• Documentation with July dates, references to missing files and drifting test totals.

This is not Microsoft's Recall. Microsoft's version is opt-in, protected by Windows Hello, and its keys are tied to the TPM and a virtualization-based security enclave. The homemade app's privacy claims come from the model's own implementation. Nobody has audited them. The author himself says he wouldn't use any Recall-style tool.

There are two other caveats. This is one run on a 128 GB machine, and results elsewhere may differ. The missing web search also probably made some steps slower and some wrong guesses more likely.

What it means for Windows users and admins​

• Hardware class matters. Microsoft said up to 128 GB of unified memory is part of the RTX Spark pitch. A model this size would not fit on a typical laptop.
• Certification is not the same as a working feature. Admins buying "Copilot+" hardware should check which experiences are actually enabled before promising them to users.
• Agent output needs review. The best catches here came from long runs, restarts and real data, not from the model's own unit tests. The worst failures were silent fallbacks, a wrong diagnosis and a made-up API claim.

The experiment shows a local model can grind through a messy Windows on Arm build with little help. It also shows why a human should still read the build log.