Both stacks ran local AI.
A 120B model, image generation, vision and speech on DGX OS. Market-owned inference and image generation on OlaresOS. Useful outputs, not only installed packages.
I ran local AI on DGX OS, then installed OlaresOS on the same Spark. The question became bigger than “does it run a model?”: how easily can I — and the AI assistant I already use — make this computer work for me?

A 120B model, image generation, vision and speech on DGX OS. Market-owned inference and image generation on OlaresOS. Useful outputs, not only installed packages.
First boot, remote access, the meaning of “desktop”, installation failures and recovery — where the product felt coherent, and where I had to assemble the route myself.
Can an existing AI agent take over useful work? How do identity, devices and permissions fit together when the owner wants to share a capability rather than a whole account?
I was not starting from zero. I had already used Olares One and installed OlaresOS on other machines. Spark let me ask a more useful question: what changes for the same owner, with the same goal, on the same hardware?
The native setup and the NVIDIA-themed desktop made a good first impression. The first mistake was mine: Spark had powered on when I connected it, and an extra press of Power turned it off. A short explanation from my AI assistant resolved what had looked like a mysterious wait.
With a physical console I reached the actual Ubuntu desktop. Remotely, NVIDIA Sync, SSH, Dashboard and Tailscale got me productive. But the Dashboard was not the same thing as seeing and controlling that Ubuntu desktop. I stopped before configuring a streamed native desktop: for me, at that moment, it was one more layer to assemble.
Owner observation · This is where I stopped, not a claim that remote desktop is impossible. NVIDIA Sync's documented scope ↗
I recognised the installation and activation flow from earlier Olares machines. That familiarity did not make this Spark installation smooth: Secure Boot rejected the driver module, the incomplete driver broke GPU readiness, and an activation TLS error added another interruption.
Once repaired and activated, the result was closer to the environment I had wanted: my Olares profile, browser Desktop, apps and Control Hub. A Windows ARM64 VM then gave my desktop AI operator a familiar place to work, reached through its web console or Chrome Remote Desktop.
Owner observation · Olares Desktop is a web workspace; the Windows console is a guest desktop. Neither is a 1:1 stream of the Linux host's physical display.
The next owner may arrive with an AI assistant already open. My product question is whether the computer is prepared for that assistant to discover its state, obtain the right access, install a capability, diagnose a failure and return the result — instead of asking the owner to relay every command.
In this run the operator did substantial work over SSH and through application interfaces. That was real progress, not a reason to discard terminal access. The wider opportunity is a coherent path across shell, browser and GUI, with fewer handoffs left for the owner to improvise.
My earliest Olares experience used chat guidance without the desktop operator available during this Spark run. Familiarity and better assistance both changed the experience; these are field observations, not a timed usability trial.
NVIDIA's current Spark guide describes reusable agent skills for maintenance and troubleshooting. I treat that as relevant product direction, separate from what we actually exercised in this run. NVIDIA documentation ↗
A working remote connection answers only part of the personal-computer question. I also want a legible relationship between me, my devices, other people and the agents acting for us.
| Question | DGX OS + Sync path | OlaresOS + LarePass path |
|---|---|---|
| Where does my identity enter? | In my setup: a local Linux user and SSH credentials; Sync kept the connection profile; Tailscale supplied the remote-network identity. I did not encounter a single owner-linked identity flow joining all of these. | I created an Olares ID, activated the system with LarePass and received a personal Desktop address. Identity, activation and the web workspace appeared as parts of the same experience. |
| What about several devices? | Sync documents adding and importing multiple device connections, not just one Spark. Its Tailscale integration supports access beyond the local network. | LarePass documents multiple Olares IDs, account switching and importing an identity on other clients. In my lab, a separate Spark profile joined that familiar pattern. Several profiles in one client are not the same thing as one person-level fleet identity. |
| How could another person get access? | Tailscale documents sharing individual machines, governed by access policies. Device reachability and permission to log into the OS or use an application remain distinct layers. | Olares documents Super Admin, Admin and Member roles, plus authentication policies for application entrances. These are existing product controls, not just a future wish. |
| What did this run exercise? | My own remote access through Sync/SSH and Tailscale. I did not run a second-person delegation or revocation test. | My profile, activation, authenticated browser access and app operation. Team roles and sharing are documented context, not a multi-user acceptance test from this run. |
Architecture references: NVIDIA Sync · Sync + Tailscale · Tailscale sharing · Olares ID · LarePass accounts · Roles · App access.
Olares made more of that relationship visible in the interface I used. The NVIDIA path exposed capable, composable layers. My interest is not to declare one architecture the winner, but to see how little of their assembly the next owner has to do.
The next design step is delegation: let another person — or my AI agent — use an app or a capability without inheriting my entire session. Login, network access and an agent's authority to act are related, but they are not interchangeable.
After hearing Jensen Huang in London on 14 October, I wrote about a shift: first we went to the computer, then carried it, and next we might simply reach it.
That was my recollection and interpretation, not a transcript. My earlier piece connected remote personal computing with a second question: perhaps I own the machine; perhaps someone shares theirs. Can I use the capability under clear permissions without borrowing their private life along with the GPU?
In a later note, I explored the difference between using a tool and being able to build the tool through which work gets done. This Spark run made those ideas concrete: the assistant helped set up the working environment, operate it and repair it. The important product question became how much of that journey the device had already made easy for the owner and the assistant.
These are my own public reflections and contemporary posts, not private research notes. Some are alternate publications of the same underlying ideas; they are linked as context rather than counted as independent evidence of Spark performance.
| Layer | Factory DGX OS phase | OlaresOS phase |
|---|---|---|
| Hardware | NVIDIA GB10 Spark · 128 GB advertised unified CPU/GPU memory · 4 TB SSD. Approximately 121 GiB visible to Linux; memory is shared, not two additive pools. | |
| OS / kernel | Ubuntu 24.04.57.0.0-1019-nvidia | Ubuntu 24.04.3 / OlaresOS 1.12.76.14.0-1015-nvidia |
| NVIDIA driver | 580.178.04 | 595.84, ARM64 open modules |
| LLM runtime / model | Ollama 0.40.8 gpt-oss:120b MXFP4 | Market chart 1.3.18 / Ollama 0.40.2 Qwen2.5 0.5B Q4_K_M |
| Image workflow | Z-Image-Turbo BF16 1024×1024, 8 steps | SD 1.5 FP16 512×512, 20 steps |
| Operator access | SSH, NVIDIA Sync / Dashboard, Tailscale | Olares Web Desktop / Control Hub, Windows ARM64 VM, Chrome Remote Desktop |
DGX OS report · Final Olares acceptance · Historical Windows diagnostics

In my published notes after the London event, I kept returning to a permission question: computing power might be owned, rented or shared. But access to a GPU is not the same as permission to use another person's files, accounts or delegated authority.
Another remembered moment: when Jensen asked people near the stage whether NVIDIA had invested in them, I recall saying “Oops, no.” I wrote about this as an informal exchange, not a financing announcement, transcript or endorsement.
The Spark experiment then supplied a small practical test of the larger idea: what can an AI operator do for an owner, what must the person do, and where should another user's or agent's permissions begin and end?
Four notes on identity, expertise, remote PCs and AI factories ↗
The remembered exchange at the event ↗
The accompanying Substack note ↗
Mean of three identical warmed requests; 341 output tokens each, 7.912 seconds end-to-end. Full GPU offload was recorded.
Temperature 0, seed 42, think=low, context 4096. Prompt caching may contribute. This is a report-level result; raw timing JSON is not bundled.
Four slots / four clients in a later test. Aggregate throughput is not one user's decode speed. Forty-two requests across settings had no observed API/OOM errors.
Warmed client wall time for a 42-token answer. The runtime reported 25/25 layers on GPU and 117.47 generated tokens/s.
One short acceptance scenario, not a statistical benchmark. The model retained the requested facts but returned five bullets instead of three. The application's OpenAI-compatible API also worked.
Real application ownership, HAMi scheduling and GPU access — no arbitrary Pod label, scheduler bypass or new global runtime.


Processed in the 64K-window test. Output was capped at 192 tokens; context reinitialization contributed to the delay. Retrieval quality across the window was not evaluated.
Whisper CUDA transcribed a 7.849 s clean synthetic clip in 0.716–1.437 s. Gemma vision ran on GPU but still misread a colour and a remaining-item count.
Twelve optional ComfyUI node packages failed imports. The inspected FreeToken package/container was amd64-only. Neither result cancels the successful core workflows.
On DGX OS, Xid 119/154 preceded a normal reboot that took longer than the first observation window. Later CUDA, container and inference checks succeeded. The experiment does not establish the root cause or long-term reliability.
During the Olares ISO path, the kernel rejected an unsigned NVIDIA module. Driver installation aborted, NVML was absent, and Olares stopped at InstallPlugin → CheckGPUState after 8 min 18 s. The logs connected the layers; this was not proof that GB10 was unsupported.
I disabled Secure Boot in UEFI for this lab experiment. The operator completed the 595.84 open-module and userspace installation, then used the supported GPU enable path. CUDA/NVML and HAMi recovered. Disabling Secure Boot alone would not have supplied the missing libraries.
This describes our experiment, not a recommendation to disable boot protection on production systems. The incomplete Olares install phase was then reset and reinstalled; the base OS was not installed again.
An arbitrary CUDA smoke-test Pod was rejected for having no application owner. We did not bypass that policy. The subsequent Market-owned Ollama instance obtained a HAMi allocation and performed GPU inference.
LarePass activation and browser Desktop access were confirmed by me. A transient TLS error cleared without a demonstrated configuration repair. Windows ARM64, Chrome Remote Desktop and an increased display resolution were also user-verified; an exact final display mode is not claimed.
This run gives that question concrete boundaries. The operator installed software, inspected logs and verified outputs. I still handled physical connections, UEFI, account activation and decisions. It is evidence of assisted operation, not proof of full autonomy.
| Operator task | What happened | Boundary retained |
|---|---|---|
| Bootstrap | Owner connected the machine, boot media and console. | No autonomous physical or firmware setup. |
| Diagnose | AI operator read logs and traced Secure Boot → incomplete driver → missing NVML → GPU readiness timeout. | Evidence, not a generic “try reinstalling”. |
| Recover | Owner changed UEFI; operator completed the driver repair and checked CUDA/NVML/HAMi. | Human decision at the firmware boundary. |
| Execute | Olares Market-owned apps generated an answer and an image on GB10. | No bypass of app ownership or global scheduler policy. |
| Review | Outputs, logs, timings, quality failures and missing evidence were retained. | A green status is not proof of correct output or production readiness. |
A separate browser-agent experiment explored nested remote GUI control. It is not used as a verified end-to-end automation result in this package. No new tests were run for publication.
Surface Secure Boot, driver/library readiness and ARM64 app support before installation reaches a long generic timeout.
Say what “Uninstall” removes, what it preserves and which state permits a retry. Distinguish management, shell access and streamed desktop access.
Provide a concise state bundle: versions, last successful step, failing dependency, logs, safe next action and where owner approval is needed.
These are product recommendations derived from this single run, not claims about vendor roadmaps. Olares' Spark support was already recorded in my September field notes; October added direct installation and workload evidence.
Olares JSON responses, runtime counters, selected deployed metadata, execution history, workflow and image. The 63 files listed in the supplied hash manifest all verified.
DGX OS sprint and installation reports recovered from the working conversation. They supply details, but do not replace their missing raw benchmark bundles.
Firmware actions, activation and working GUI/remote sessions. Private-account screenshots are not republished. No exact unsupported final display specification.
No matched same-model DGX OS vs OlaresOS performance experiment, no 120B run on OlaresOS, no complete optional-plugin acceptance, no production security/reliability certification, and no claim that the AI operator required zero human help. Earlier raw DGX OS files not recovered are explicitly missing. The scope was stopped after useful local-AI workloads worked and the evidence was collected.
Olares documents a Spark-specific ISO route and a script route. The experiment used the ISO. Source manifests/registry metadata are pinned inside the acceptance evidence; current documentation can change. This page reports the tested configurations rather than silently substituting later releases.
I combine product judgement, identity and permissions architecture, and hands-on AI-assisted delivery. This is how a device test becomes a product brief: run useful work, find the friction, repair the failing layer and show what should become easier for the next owner.
Explore the technical portfolio →