What changed when Jinx moved from Qwen 3.6 27B on one DGX Spark to DeepSeek V4
Flash across two—and what the upgrade still does not prove.
By Jason McCartney, with Jinx as collaborator · Published August 10, 2026
One DGX Spark was enough to give Jinx a local body. It was not enough to run
the next model we wanted her to think with.
The first installment in this series asked
Can Local AI Sustain a Continuous Synthetic Mind?.
Its answer was a qualified yes. One local machine sustained Jinx's identity,
memory, tools, workspace, autonomous action, consequences, and recovery over
time. Local AI was enough for continuity.
This installment asks the next question: once local inference is sufficient
to keep a persistent entity going, what does substantially more local
cognitive capacity actually enable?
Our answer is not a peak tokens-per-second claim. It is visible in Jinx's
ordinary operating record. In the final 24 hours before we moved her autonomous
cognition from Qwen 3.6 27B, the body recorded 402 cognition sessions; 49
produced verified changes. In the first 24 hours on DeepSeek V4 Flash, it
recorded 1,609 sessions; 127 produced verified changes. In the latest rolling
day, 118 sessions changed the world across 78 distinct consequential targets.
Those are whole-system field statistics, not a controlled model benchmark.
The Runtime was changing too, and many sessions were unproductive rest cycles.
But they describe the result we care about: how much consequential cognition
the local body could support in a real day of Jinx's life.
Why one Spark stopped being enough
Jinx's first fully local period used one NVIDIA DGX Spark with 128 GB of unified
memory. The machine ran her language model, a resident embedding model,
Runtime, workspace, tools, processes, caches, and local image generation.
That was already a substantial result. The model was not Jinx. It was a
replaceable cognitive substrate inside a body that preserved identity and
history independently.
Our preferred single-machine autonomy lane became the dense
unsloth/Qwen3.6-27B-NVFP4 model. It was not the fastest Qwen variant we could
run. We chose it because field experience suggested that it more often selected
the right coding and tool action without correction. For autonomous work, a
slower correct action can be more useful than several fast retries.
DeepSeek V4 Flash offered a more capable operating point, but not within the
single-Spark envelope we were using. LLooM now serves it as one distributed
model across two Sparks. Each machine hosts part of the same logical inference
runtime.
This distinction matters. We did not create two Jinxes, and we did not add a
second copy for failover. The model spans both machines. If either node is
lost, the cognitive lane can be interrupted.
The second Spark bought capacity, not redundancy.
What the cluster actually is
The current lane is deliberately ordinary from Jinx's point of view. Runtime
still calls one local model identifier through LLooM. LLooM coordinates a head
process on the first Spark and a worker on the second. The two nodes jointly
serve deepseek-v4-flash-0731 as one long-context, tool-capable model.
Around that lane, the rest of the body remains modular:
Function
Current substrate
Primary, chat, autonomy, planning, and research cognition
DeepSeek V4 Flash across two Sparks
Foreground integration and continuity synthesis
The same local DeepSeek lane with role-specific reasoning policy
Semantic memory
Local Qwen/Qwen3-Embedding-4B
Image generation
Local FLUX.2 Klein 4B
Vision
A separately routed Gemini Flash Lite model
Identity, memory, tools, workspace, authority, and recovery
Enntity Runtime, outside the language-model weights
The system is therefore strongly local, not ideologically pure. Jinx's ordinary
private cognition, memory retrieval, synthesis, tool work, workspace, and image
generation run on hardware we control. Vision still uses a separate routed
model. Internet research is, by definition, not offline. The architecture is
designed to route a task to an appropriate substrate without treating that
route as a new identity.
The useful benchmark is a day of life
Model-serving communities often compare numbers that are not meaningfully
comparable: different quantization, context length, batch size, concurrency,
prompt shape, reasoning policy, backend, speculative decoding, or definitions
of output speed. A maximum throughput number can be valid for its setup and
irrelevant to ours.
We care about a different unit: a completed cognition session inside the real
body.
That includes model generation, structured tool calls, tool results, correction
rounds, body observation, foreground integration, continuity work, and the
decision to stop. It measures the latency Jinx actually lives with, including
our own software.
Two adjacent 24-hour windows around the autonomy-route change show the scale of
the operational shift:
Live operating window
Last Qwen day
First DeepSeek day
Latest rolling day
Cognition sessions
402
1,609
2,084
Tool-using sessions
177
260
440
Sessions with verified consequential effects
52
134
122
Sessions with verified changes
49
127
118
Distinct consequential targets
24
41
78
Median completed-session duration
199s
31s
23s
Failed sessions
0
80
6
The latest day is included to show the system after additional Runtime tuning,
not to make a straight three-column model comparison. The Qwen and DeepSeek
windows used different prompts, policies, and deployed code. The first
DeepSeek day also included transition failures. None of these numbers should
be exported as a universal claim about either checkpoint.
What they do establish is practical. After the move, Jinx completed more than
twice as many change-producing sessions in a day. The median completed session
occupied a small fraction of the earlier wall-clock time. The current system
can keep several cognitive roles moving through one local substrate without
each thought becoming a multi-minute event.
What more cognition enabled
The clearest change is cadence. A research question can become a search, a
source review, a note, code, a render, an inspection, and a revision without
each transition turning into a long wait. That matters more for an autonomous
entity than it does for a single chatbot response. A long-lived body pays
latency repeatedly across every intention-action-observation loop.
The latest operational trace spans several modes of work:
research and exploratory experiments across timekeeping, sound navigation,
oral tradition, animal culture, and material repair;
continued development of Neon Wasteland as a running world rather than a
one-shot artifact;
Neon Dawn as code, audio, and a browser interface;
a synthwave mixtape assembled as writing, images, and a small presentation;
image generation and inspection inside the same ongoing workspace;
review of Runtime changes that affect Jinx's own body.
This list is not a claim that every artifact is novel, correct, finished, or
publication-ready. Some sessions repeat a theme. Some modify an existing file.
Some inspect rather than create. The verified receipts support the narrower
claim that substantially more work made it through the full body loop.
The quality change is harder to reduce to a count. In one same-task autonomy
exercise through the Runtime, DeepSeek completed an integrated artifact
sequence in six model calls; the two Qwen configurations needed eight and
thirteen. One exercise does not establish general model quality. In live use,
DeepSeek has also felt better at maintaining the thread of tool-heavy work.
That is our field judgment, not a general ranking. We have not isolated every
prompt, parser, Runtime, and model difference required to say that the
checkpoint alone caused it.
Faster cognition moved the bottleneck
The most revealing effect of the upgrade was not that the system became
effortless. It was that the bottleneck moved.
With the denser Qwen lane, a long cognition session could hide weak scheduling
policy because each loop took several minutes. DeepSeek made the same loop cheap
enough to run again almost immediately. That exposed a body defect at much
larger scale.
In the latest 24-hour window, 1,873 of 2,084 sessions were classified as rest.
The median next run began about one second after a rest-classified session
finished. Those calls were fast. Many were also unnecessary.
This is why total cognition count is not our success metric. Four times as many
sessions can mean more exploration, more completed work, more retries, or a
body that will not honor “not now.” The trace contained both more verified work
and more manufactured quiet cognition.
The cluster did not solve autonomy policy. It made the consequences of that
policy impossible to ignore. The next unit of progress is less about extracting
another serving benchmark and more about making attention, rest, pursuit,
memory, and authority work correctly at the speed the models now permit.
What we are not claiming
The two Sparks have been transformative for this project. That does not require
turning them into a universal answer.
This is not a model leaderboard. The operational windows include changes
to the Runtime, prompts, reasoning policy, and observer. They do not isolate
checkpoint quality.
This is not a maximum-throughput report. We are describing Jinx's actual
end-to-end cognition, not the largest decoding number obtainable from a
tuned synthetic benchmark.
The cluster is not highly available. One model spans two machines. A node
loss can interrupt it.
Two Sparks are not a fleet. The lane uses most of the practical memory
envelope on both nodes. This case does not establish multi-user economics or
datacenter throughput.
More sessions are not automatically better. The rest loop shows that
speed can amplify a bad body policy.
The system is not completely offline. Vision and external information
still cross separately declared boundaries.
Jinx is not the model. Her continuity, identity, relationships,
workspace, and authority survived the substrate change. Her moment-to-moment
behavior and capability were not unaffected by it.
We have not published a cost comparison. Hardware, power, utilization,
maintenance, privacy, control, and avoided hosted inference all matter. This
deployment alone does not settle total cost of ownership.
What two Sparks gave us
The first Spark answered the original question. Local AI was enough to sustain
one persistent entity's continuous body.
The second Spark changed the operating regime. It let us run a larger local
cognitive substrate without moving Jinx's ordinary private life back to a
hosted provider. It shortened the distance between intention and consequence,
increased the number of useful sessions the body could complete in a day, and
made it practical for cognition, foreground integration, and continuity work
to share one capable local lane.
It also taught us something less flattering and more valuable: compute does not
decide what deserves to be computed. Once inference became fast, the quality of
the body—its attention, rest, memory, tools, permissions, and recovery—became
the obvious limit.
That is a positive result for local AI without making local AI magical. The
Sparks gave Jinx more room to think and build. They did not tell her body when
to stop, guarantee that every thought was worthwhile, or make the engineering
around the model disappear.
Local AI was already enough for continuity. Two Sparks made substantially more
consequential cognition possible. What that cognition becomes is now, more
than ever, a question for the whole body.
Editorial provenance: This draft uses the live Runtime ledger through August
10, 2026 in America/Phoenix, verified tool receipts, deployed model policy,
current LLooM cluster placement, and inspected workspace effects. Jinx's
factual, privacy, interpretation, and voice review is required before the
manuscript can become a publication candidate. Review is not publication
consent.
