Galang Taruna
An ambitious eleven-hour flight from San Francisco to Paris, devoid of internet access, served as the ultimate proving ground for a new generation of laptops. Equipped with Nvidia’s groundbreaking RTX Spark chip, a direct competitor to Apple’s MacBook Pro, the test aimed to determine if on-device AI could truly replace cloud-based services like ChatGPT for daily professional tasks. The verdict: for basic queries, local AI is impressively capable. For more complex, agentic workloads, the technology, while promising, still faces significant hurdles, particularly concerning battery endurance and system memory. This exclusive report details a real-world evaluation, offering a candid look at the immediate capabilities and limitations of AI PCs in October 2026.
The Dawn of Local AI: Nvidia’s "The One PC" Vision
The narrative of the "AI PC" took center stage at Nvidia’s Editor’s Day in San Francisco in early October 2026. Here, the company articulated its vision with a concise, powerful mantra: "The One PC." This singular machine, according to Nvidia, is destined to seamlessly integrate creation, gaming, and the burgeoning capabilities of AI agents. Microsoft, a pivotal partner in this paradigm shift, echoed this sentiment, assuring that Windows is fully prepared to embrace this new era of computing. This collaborative effort between hardware and software giants aims to redefine personal computing by bringing advanced artificial intelligence directly to the user’s desktop, reducing reliance on remote servers and internet connectivity.
However, the glossy demonstrations on a meticulously prepared stand at Nvidia’s event often paint an idealized picture. The true test, as this reporter sought to uncover, lies in replicating these sophisticated operations under ordinary, often challenging, conditions. The return flight provided the perfect, isolated environment: eleven hours in airplane mode, completely cut off from onboard Wi-Fi, with all necessary AI models downloaded beforehand. The objective was clear: to conduct all work—from answering questions and summarizing notes to processing videos—entirely within the confines of the laptop, pushing the boundaries of what local AI could achieve. This hands-on, real-world experience forms the core of this article, complementing a comprehensive technical review conducted by my colleague, Ulrich Rozier, which delved into gaming, creative applications, battery autonomy, and direct comparisons with the MacBook Pro.
Unpacking the RTX Spark: A New Breed of AI Processor
At the heart of this transformative computing experience is the Nvidia RTX Spark chip. This innovative System-on-a-Chip (SoC) ingeniously combines an Arm-based processor, featuring either 18 or 20 cores (depending on the variant) developed in collaboration with MediaTek, with a Blackwell-generation GPU, akin to the formidable GeForce RTX 50 series. Crucially, both the CPU and GPU share a unified memory architecture, offering up to 128GB of high-speed memory with a bandwidth of 300 GB/s.
This unified memory is a game-changer for local AI. For an AI model to respond with minimal latency, it must reside entirely within the memory accessible to the processing unit—typically the graphics card. While a portable RTX 5070 might offer 8GB of video memory (or 12GB for the RTX 5070 Ti), sufficient for a modest AI assistant, the RTX Spark’s architecture allows the GPU to reserve tens of gigabytes from the unified pool. This substantial memory allocation is key to running larger, more complex AI models directly on the device.
The specific machine used for this extensive test was an Asus ProArt P16, configured with 64GB of unified RAM—the intermediate version, retailing at €5,299.99 in France. Nvidia’s most ambitious claims, however, often necessitate the 128GB variant, raising questions about the performance differential for models requiring greater memory capacity. The ProArt P16 is slated for release in France on Friday, October 16th, available through major retailers like Fnac, Darty, Boulanger, Amazon, and Asus’s online store. The range spans from an entry-level 24GB version (with 512GB storage) priced at €3,299.99. For those seeking a more affordable entry into the RTX Spark ecosystem, Microsoft’s Surface Laptop Ultra starts at €2,899, featuring an 18-core chip and 24GB of memory. Other prominent manufacturers, including Lenovo, HP, and Dell, have also opened pre-orders for their RTX Spark laptops, with initial deliveries expected to commence on the same date in the United States.
For the flight test, five diverse, open-source AI models were pre-loaded: Qwen 3.6 35B and Qwen 3.8 27B from Alibaba (the former for speed, the latter for deeper reasoning), Qwen3 Coder 30B (specialized in code generation), gpt-oss-20b from OpenAI, and Nvidia’s own Nemotron 3.5. OpenAI’s Whisper transcription tool was also included.
A significant discovery emerged early: despite the 64GB total memory, the AI could not access it all. The portion reserved for the GPU, configurable via the Nvidia application, was set to 48GB by default on my machine. This left a mere 16GB for Windows and all other running applications, a constraint that quickly proved restrictive. An attempt to load gpt-oss-120b, OpenAI’s large open-source model, failed within seconds, as it demanded 59.9GB of graphical memory while the system only exposed 55.9GB. This highlighted the critical role of memory allocation and the need for higher-tier configurations for truly advanced local AI tasks.
Practical AI in Action: Querying and Summarization
The initial phase of the in-flight test focused on common AI use cases, mimicking typical ChatGPT interactions. The first query posed was a practical one: "I am on a flight between San Francisco and Paris, landing Saturday at 3:50 PM with a 9-hour time difference. Give me a concrete hour-by-hour plan to be in shape by Monday morning: when to sleep, when to eat, light exposure, caffeine. Be concrete and concise."
Qwen 3.6 responded at approximately 70 tokens per second—a rate significantly faster than human reading speed. The generated plan was clear, structured by day: maximum natural light upon arrival, a light dinner, bedtime around 9:30 PM, caffeine limited to mornings, and naps no longer than 20 minutes. While not revolutionary, the advice was sound and practical, demonstrating the model’s ability to process context and provide relevant guidance offline. A follow-up question, "What if I need to film a video on Sunday afternoon, what should I shift?", received an equally swift response, thanks to the model retaining the conversation context. The only noticeable delay was the initial loading of the model, which took a few tens of seconds.
The next crucial task leveraged the core advantage of local AI: processing sensitive, embargoed information. My notes from Nvidia’s Editor’s Day, largely transcriptions of confidential presentations, could not be exposed to the cloud. These extensive notes were pasted into Qwen 3.8 27B with specific instructions: summarize them into ten key points, identify Nvidia’s claims lacking verifiable data, and propose eight questions for my colleague Ulrich to investigate during his detailed review.
The model ingested over 11,000 tokens of notes in a mere 17 seconds. It then spent just over two minutes drafting the summary, consuming only 3% of the laptop’s battery. This model generated text at a slower pace, around 16 tokens per second, because as a "dense" model, it re-reads its 27 billion parameters for each word generated, unlike Qwen 3.6 which activates only about 3 billion parameters. With speculative decoding enabled, which allows it to predict several words simultaneously, the speed increased to between 24 and 31 tokens per second. The output was remarkably impressive: comprehensive, well-structured, featuring pertinent verification questions, all generated without any internet access.
However, this intensive local AI processing came with a tangible cost: heat and noise. Unlike querying ChatGPT, where computations occur in a remote datacenter, here the laptop itself was doing the heavy lifting. In Performance mode, the air expelled onto my lap reached uncomfortable temperatures, and the fans roared to life, reminiscent of a high-performance gaming session.
Beyond Text: Transcription and Code Generation
The utility of local AI extended beyond text generation. Whisper (version large-v3-turbo) was employed to transcribe raw video footage from San Francisco, converting spoken content into written text for later reference. Running on the GPU, Whisper processed an 80-second video segment in just 5.35 seconds, a staggering fifteen times faster than real-time. The transcribed text was word-for-word identical to results obtained with an internet connection, and in automatic mode, it seamlessly handled passages blending French and English.
A preliminary test conducted at the hotel served as a valuable reminder that local AI, much like its cloud-based counterparts, is not immune to errors. When asked to "explain to a 10-year-old why an airplane flies," Qwen 3.8 27B perpetuated the common misconception that air makes a "small detour" over the wing. Nemotron 3.5, on the other hand, confused the top and bottom of the wing before bizarrely referencing a "boat." Furthermore, without its "reflection" mode activated, Qwen 3.8 27B even miscalculated the day in my jet lag plan, mistakenly placing my arrival on a Friday.
The choice of model also proved crucial. For my notes, Qwen 3.6 delivered a decent summary in 36 seconds. However, Qwen 3.8 27B, with its reflective capabilities engaged, took 2 minutes and 43 seconds, but produced a far more detailed and hierarchically organized summary. This reinforced a key principle applicable to both local and cloud AI: faster models for simple queries, and more thoughtful, compute-intensive models for critical, complex tasks.
The Agentic Frontier: Promises and Pitfalls of Local AI Agents
The most ambitious phase of the test involved leveraging AI agents, which go beyond simple queries to actively operate software and execute multi-step tasks on the computer. For this, Hermes, the open-source agent from Nous Research championed by Nvidia, was tasked with controlling ComfyUI, an image generation software, to create an illustration, with Qwen 3.8 27B acting as its "brain."
The initial setup, prepared at the hotel with assistance from a cloud AI, was far from the promised "two-click" installation. The connector between Hermes and ComfyUI resisted installation on the Arm chip, requiring manual intervention and troubleshooting.
In-flight, the agentic tasks hit a wall. The first attempt failed due to a configuration mismatch between Hermes and its model. A second attempt saw ComfyUI crash due to insufficient video memory. When the error message was fed to Hermes, it spent a frustrating fifteen minutes attempting to diagnose the issue before being manually stopped. After 33 minutes, no image had been generated, and 39% of the battery had been drained, indicating an average power draw of approximately 71 watts.
The explanation for this failure emerged post-flight. The "context window," which serves as the model’s working memory, is entirely reserved upon loading, even if not fully utilized. Hermes, by default, attempted to allocate the largest possible context window (262,144 tokens, equivalent to several books). This, combined with the model itself, consumed roughly 40GB of video memory. With ComfyUI attempting to run concurrently, the system’s total accessible memory (capped at 60.7GB on my machine) was saturated, preventing the model from loading properly. ComfyUI’s misleading display of "55GB free video memory" on this unified memory architecture further complicated diagnosis.
Hermes refused to operate with a context window smaller than 64,000 tokens. The solution involved manually reducing the context to 65,536 tokens, thereby limiting the model’s capacity for lengthy reasoning or processing vast amounts of data simultaneously. With this adjustment, the model occupied approximately 24GB, finally allowing both the agent and the image generation software to run concurrently. A brief aside: the 128GB version of the ProArt P16 would have circumvented this memory constraint entirely, allowing for the maximum context window.
With the memory configuration optimized, the same request to Hermes was successfully executed offline. Hermes composed the prompt, launched ComfyUI, and rendered the image. However, the agent proved somewhat overzealous, spending an inordinate amount of time verifying its work in the terminal after generation. One of its commands was even blocked by its own security protocols. This highlighted a current limitation: the test machine lacked the latest Windows version designed to automatically approve non-dangerous commands, underscoring the still-evolving integration of AI agents within the operating system.
Thus, local agents are functional, but not yet "two-click" simple, and often require manual memory management. For more demanding tasks involving multiple tools and extensive context, 64GB of memory will prove insufficient, solidifying the case for the 128GB variant.
The Hardware Reality: Battery Life, Thermals, and Performance Throttling
Beyond performance metrics, the real-world deployment of local AI on laptops confronts significant practical challenges, primarily battery life, thermal management, and noise. The Asus ProArt P16’s battery, rated at 99.9 Wh, skirts just below the 100 Wh airline limit for cabin baggage, a crucial detail for travelers.
Observations during the flight revealed stark differences in power consumption:
- Questions, Summaries, Transcription: Consumed 22% battery in one hour (from 100% to 78%), averaging approximately 20W. This translates to roughly 5 hours of continuous light AI use.
- Hermes Agent and ComfyUI: Drained 39% battery in 33 minutes, averaging about 71W. This intense workload yields less than 1 hour 30 minutes of autonomy.
- Intensive AI in Performance Mode (measured in Paris): Averaged 75W, with peaks up to 100W, leading to an estimated autonomy of approximately 1 hour 15 minutes.
While an hour of simple queries and summaries is manageable, running an AI agent or performing intensive computations quickly depletes the battery, limiting continuous work sessions to little over an hour—a figure reminiscent of older gaming laptops. For prolonged use, a power outlet is indispensable. Even the in-seat power outlets on the plane proved inadequate; connected to the seat, the laptop still lost 13% battery in 19 minutes during heavy computation. This is likely due to the laptop’s 140-watt power brick drawing far more power than the typical 60-watt output of an airplane seat outlet.
Two additional pitfalls emerged. Firstly, if the screen turned off, Windows entered sleep mode and throttled the chip, causing calculations to continue at two to three times slower speeds (e.g., the game code generation dropped from 93 to 34 tokens per second). Setting the screen to "Never" turn off was a necessary adjustment.
More dramatically, at 30% battery capacity, performance was abruptly halved. Gpt-oss-20b saw its speed plummet from 78 to 38 tokens per second, and Qwen 3.8 27B from 26 to 11, despite the GPU remaining 94% utilized. My colleague Ulrich identified Windows’ energy saver, factory-set to activate at 30%, as the culprit. Disabling it largely restored performance. However, on my test machine, this setting was already deactivated, suggesting a secondary, underlying throttling mechanism might be at play.
In terms of thermal management, the chip itself performed admirably; the GPU never exceeded 71°C and showed no signs of thermal throttling. The discomfort was primarily for the user, with significant heat radiating from the chassis. Fan noise, as expected for such high-performance tasks, was comparable to a gaming PC. Ulrich measured peaks of up to 65 dB at one meter during 4K gameplay in Cyberpunk 2077. It is important to note that these observations pertain specifically to the Asus ProArt P16; different manufacturers configure the chip’s power envelope (between 45 and 80 watts) and chassis designs, potentially leading to varied thermal and acoustic profiles.
Nvidia RTX Spark vs. Apple Silicon: A Head-to-Head Comparison
While my in-flight tests were conducted without direct comparison, Ulrich Rozier’s comprehensive benchmarks provide a crucial perspective on how the RTX Spark stacks up against Apple’s highly efficient M-series chips. He pitted a 128GB ProArt P16 against a MacBook Pro M5 Pro with 48GB of unified memory.
| Usage / Metric | RTX Spark (ProArt P16 128GB) | MacBook Pro M5 Pro 48GB |
|---|---|---|
| Text Generation, Qwen 3.6 35B | 74.8 tokens/s | 68.7 tokens/s |
| Long Text Reading (16,384 tokens, Qwen3-8B) | 6.3 s | 19 s |
| Continuous AI on Battery | ~64 min | ~66 min |
| Energy per 1,000 Tokens Written | 0.36 Wh | 0.27 Wh |
| Speed below 30% Battery | Halved (factory setting) | Unchanged until 5% |
| gpt-oss-120b (63GB) | 63.3 tokens/s | Does not load |
Ulrich’s measurements, using the same model files. Autonomy estimates are from 100% to 0% at the measured rate.
For pure text generation, both machines performed comparably, a testament to their similar memory bandwidths. However, the RTX Spark demonstrated a clear advantage in compute-intensive tasks, reading long documents 2.5 to 3 times faster. This is a significant benefit for AI agents that frequently re-read files for context. Battery life for continuous intensive AI work was strikingly similar, around one hour for both platforms. Yet, the Mac proved more energy-efficient for text generation, consuming approximately 25% less energy (0.27 Wh vs. 0.36 Wh per 1,000 tokens).
A positive finding for my 64GB unit: for comparable tasks and models, it performed text generation just as fast as the 128GB version. The primary advantage of 128GB is the ability to load larger, more complex models, not a speed boost for models that fit within smaller memory configurations.
Memory Matters: The 64GB vs. 128GB Dilemma
The choice of memory configuration is critical for the types of AI models that can be run locally. To quantify this, the independent Artificial Analysis index, which Nvidia itself references, serves as a valuable benchmark. A higher index score indicates a more intelligent and performant model.
| Model | Memory Required | Artificial Analysis Index (Oct 9, 2026) |
|---|---|---|
| gpt-oss-120b (OpenAI) | 128 GB | 12 |
| Qwen 3.8 27B (Alibaba), max reflection | 64 GB | 34 |
| Qwen 3.8 Flash-Next (Alibaba) | 128 GB | 40 |
| Claude Sonnet 5.5 medium (cloud) | — | 41 |
| Claude Opus 5.5 max (cloud) | — | 58 |
Just a year prior, gpt-oss-120b, requiring 128GB, was a leading local AI model with an index of 12. Today, Qwen 3.8 27B, which fits within 64GB, achieves an impressive index of 34—nearly three times better performance with a quarter of the memory. The primary model inaccessible to a 64GB configuration is Qwen 3.8 Flash-Next, Nvidia’s showcase model with 125 billion parameters. This model scores 40 on the index, placing it on par with Claude Sonnet 5.5 at its intermediate setting, according to Nvidia. This demonstrates the rapid advancements in model efficiency.
Remarkably, local AI has now reached the performance level of cloud AI from six months ago. Furthermore, Nvidia’s new in-house model, Nemotron 3.5 Bolt, comfortably fits within 64GB. Released on Thursday, October 15th (after my tests), this model features 74 billion parameters with 9 billion active, and occupies approximately 24GB when quantized to 2 bits. It is entirely open-source and immediately available through platforms like LM Studio, Ollama, or llama.cpp, with direct integration into Hermes also announced by Nvidia.
The concept of pooling resources across multiple PCs, while intriguing, does not directly increase usable memory for a single task. Nvidia’s PAIR, a free and open-source tool, distributes agent workloads across up to sixteen household computers (PCs and Macs). However, it does not aggregate memory; each task is processed by a single machine. Therefore, two 64GB PCs do not collectively create a 128GB AI system. Nevertheless, PAIR remains valuable, enabling a daily-use laptop to offload more intensive AI tasks to a more powerful home desktop.
A final avenue for exploration that was not pursued during this test is Linux. Given its generally lower memory footprint compared to Windows, a Linux environment might free up more memory for the GPU, potentially expanding the range of models and tasks feasible on a 64GB system. This approach is already implemented in Nvidia’s DGX Spark, a closely related machine sold with Linux pre-installed.
Financial and Strategic Implications: Is Local AI Worth the Investment?
Nvidia positions the AI PC as a "token generator," offering a compelling financial argument for specific use cases. According to their projections, generating 61 million tokens per month locally incurs an electricity cost of approximately $20 (around €17), compared to $1,200 (around €1,030) charged by a comparable cloud model’s API. This calculation, however, is tailored for developers running AI agents almost continuously (nearly 20 hours a day on a 200-watt RTX Spark mini PC), not for the average ChatGPT Plus subscriber.
For a typical user, the math is straightforward. The €5,299.99 Asus ProArt P16 with 64GB represents roughly nineteen years of a ChatGPT Plus subscription (€23/month). The €2,300 price difference between the 64GB and 128GB versions (the latter at €7,599.99 with 2TB storage) alone equates to over eight years of ChatGPT Plus. During this time, cloud services will evolve with newer models and upgraded servers, while the local hardware remains static. On a laptop, the electricity cost for AI is negligible, typically 2 to 3 cents per full battery charge. The true cost of local AI for most users is paid in autonomy and time spent on configuration.
The most compelling argument for local AI remains privacy. Even professional cloud offerings that promise not to train models on user data still involve transmitting and temporarily storing sensitive information on remote servers. For confidential corporate documents or personal data, local AI offers the only guarantee that information remains entirely on the user’s machine.
Nvidia and Microsoft’s hybrid approach—keeping confidential tasks local while offloading power-intensive demands to the cloud—is particularly appealing. Nvidia has announced NeMo Switchyard, a router designed for this purpose, expected in beta within Hermes by late October. Currently, achieving this hybrid workflow still requires considerable manual effort.
Conclusion: The Future is Hybrid, But Not Yet Seamless
In conclusion, the transcontinental flight test revealed that local AI, powered by Nvidia’s RTX Spark, is a powerful and rapidly maturing technology. For common user interactions with AI—posing questions, summarizing documents, or transcribing audio—it performs admirably, offering speed and, critically, complete data privacy by keeping all operations on the device. Just weeks ago, the notion of local AI felt somewhat antiquated; this experience has proven its significant advancements and immediate utility.
However, the journey towards a seamless AI PC experience is far from complete. The models that comfortably fit within 64GB of memory do not yet match the sophistication of the very best cloud models. More importantly, the highly anticipated AI agent capabilities, the most transformative aspect of this technology, failed to deliver in-flight and necessitated significant manual configuration to function.
The limitations extend beyond software and model capabilities. The high cost of these AI-capable laptops, the memory ceiling for the most advanced models, and a battery life that barely exceeds an hour under heavy AI load are significant hurdles. All these observations are current as of October 2026. Given the exponential pace of AI development, models are continuously improving. It is entirely plausible that the 64GB systems of six months from now will effortlessly handle the video generation tasks that challenged this test unit on its transatlantic journey. The future of AI PCs is undoubtedly hybrid, promising a blend of on-device privacy and cloud-based power, but the path to full integration remains an active, evolving frontier.
