Slava Solodkiy / Product & systems field notes
London · 22–25 October 2026 · GB10 / ARM64 · one physical device

One Spark.
Two stacks.
One owner.

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 hands-on product and systems field study by Slava Solodkiy. NVIDIA provided the Spark as a prize/gift; the observations and conclusions are my own.

Slava holding the NVIDIA DGX Spark device during the October 2026 hands-on setup
22 October 2026 · DGX Spark in hand. The test that followed: first DGX OS, then a fresh OlaresOS installation on the same machine.
01 / Real capability

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.

02 / A usable computer

The owner has an experience.

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.

03 / The next operator

My assistant needs a way in.

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?

Two installations.
Two different experiences.

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?

DGX OS / My experience

A polished first boot.
A developer-shaped way in.

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 ↗

OlaresOS / My experience

A familiar destination.
A harder installation here.

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.

Not a better/worse scoreboard. DGX OS gave me a strong native AI foundation. Olares brought more of the personal workspace into one product surface, after a more demanding installation on this machine. Both delivered useful local AI; they asked different things of me.

User-friendly is only half the question.

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.

Agent-readiness is also becoming an explicit vendor interface

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 ↗

Can I reach my computer?
Who else can — and as whom?

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.

QuestionDGX OS + Sync pathOlaresOS + 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.

For me, “personal” is not just where the GPU lives.
It is who can use the capability, through which identity, with which rights.

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.

Personal need not
mean portable.

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.

My extension of that vision: a personal AI computer needs an operational path for its owner's existing agent, and an identity-and-permissions path for using and sharing its capabilities. This is my product conclusion from the experiment, not a feature promise attributed to Jensen or NVIDIA.

The ideas were public
before the test.

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.

The Medium, Substack and LinkedIn essays capture my product reading of the shift from carrying hardware to accessing capability. The X links are contemporaneous social notes. Article and post destinations supplied by the author; some social platforms restrict automated preview.

Same silicon.
Different software contracts.

LayerFactory DGX OS phaseOlaresOS phase
HardwareNVIDIA 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 / kernelUbuntu 24.04.5
7.0.0-1019-nvidia
Ubuntu 24.04.3 / OlaresOS 1.12.7
6.14.0-1015-nvidia
NVIDIA driver580.178.04595.84, ARM64 open modules
LLM runtime / modelOllama 0.40.8
gpt-oss:120b MXFP4
Market chart 1.3.18 / Ollama 0.40.2
Qwen2.5 0.5B Q4_K_M
Image workflowZ-Image-Turbo BF16
1024×1024, 8 steps
SD 1.5 FP16
512×512, 20 steps
Operator accessSSH, NVIDIA Sync / Dashboard, TailscaleOlares Web Desktop / Control Hub, Windows ARM64 VM, Chrome Remote Desktop

DGX OS report · Final Olares acceptance · Historical Windows diagnostics

A successful Windows guest is not NVIDIA GPU passthrough. The GPU workloads here execute on the Linux host or in application-owned Linux containers. Earlier DGX OS reports are available; most raw benchmark bundles from that phase are not included.

Permission is part of computing.

Slava at NVIDIA Build-a-Claw London beside the AuthorityClaw demonstration and a Who Gave the AI Permission display
14 October · The AuthorityClaw demonstration at NVIDIA Build-a-Claw London. This photograph documents the event, not an additional technical benchmark.
Owner's published notes · October 2026

What happens when the machine is someone else's?

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 ↗

Useful work, not a spec-sheet demo.

DGX OS / reported warm series

gpt-oss:120b

43.565 tokens/s

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.

Sprint 1 report ↗

63.62 aggregate tokens/s

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.

Parallelism report ↗

OlaresOS / attached raw evidence

Market-owned Qwen 0.5B

0.411 seconds

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.

Raw counters ↗ · GPU log ↗

The platform path was the test.

Real application ownership, HAMi scheduling and GPU access — no arbitrary Pod label, scheduler bypass or new global runtime.

Deployed workload metadata ↗

These numbers are not comparable model scores. A 120B model and a 0.5B model solve different acceptance questions. The large model was not downloaded or benchmarked again under OlaresOS.
DGX OS output: silver mini computer on a wooden table, two green mugs and a blue notebook
DGX OS / Z-IMAGE-TURBO
1024×1024, 8 steps: 14.064 s. Repeat: 17.582 s; sampling ran again, outputs matched. Extra mug and lettering violated the prompt. The first run was not a pristine cold run.
Workflow report ↗
OlaresOS output: green succulent in a brown pot on a bluish surface
OLARES / COMFYUI CORE PASS
512×512, 20 steps: 9.41 s. One uncached SD 1.5 FP16 workflow; client polling wall time was 10.132 s. A brown pot/bluish surface replaced the requested white pot/wooden table.
Execution history ↗ · Original PNG ↗
DGX OS / long context

64,688 input tokens

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.

Context report ↗

DGX OS / speech & vision

Fast did not mean correct.

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.

Multimodal report ↗

Olares / boundaries

Some parts did not pass.

Twelve optional ComfyUI node packages failed imports. The inspected FreeToken package/container was amd64-only. Neither result cancels the successful core workflows.

Exact package scope ↗

The failures are part of the result.

A GSP timeout was recoverable — its cause remains open.

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.

Initial recovery report · Subsequent successful workloads

“Installation failed” hid a specific signing failure.

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.

Failure analysis · Diagnostic excerpt

Human firmware action; agent-assisted driver repair.

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.

Recovery report

Not every Pod is an Olares application.

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.

Rejected test · Working application

GUI success is a separate acceptance result.

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.

Earlier Windows diagnosis · Evidence levels and limits

Can it run AI?
Can AI run it?

A personal AI computer should be understandable not only to its owner, but to the AI assistant that owner already uses.

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 taskWhat happenedBoundary retained
BootstrapOwner connected the machine, boot media and console.No autonomous physical or firmware setup.
DiagnoseAI operator read logs and traced Secure Boot → incomplete driver → missing NVML → GPU readiness timeout.Evidence, not a generic “try reinstalling”.
RecoverOwner changed UEFI; operator completed the driver repair and checked CUDA/NVML/HAMi.Human decision at the firmware boundary.
ExecuteOlares Market-owned apps generated an answer and an image on GB10.No bypass of app ownership or global scheduler policy.
ReviewOutputs, 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.

Make the next owner's path shorter.

Preflight the actual blockers.

Surface Secure Boot, driver/library readiness and ARM64 app support before installation reaches a long generic timeout.

Explain recovery scope.

Say what “Uninstall” removes, what it preserves and which state permits a retry. Distinguish management, shell access and streamed desktop access.

Make the handoff inspectable.

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.

Results you can inspect.
Methods you can reuse.

A / Raw 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.

B / Earlier reports

DGX OS sprint and installation reports recovered from the working conversation. They supply details, but do not replace their missing raw benchmark bundles.

C / Owner confirmation

Firmware actions, activation and working GUI/remote sessions. Private-account screenshots are not republished. No exact unsupported final display specification.

What remains unproven?

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.

Official context, distinct from this field evidence

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.

The professional output

Understand the owner.
Connect the system.
Make it work.

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 →