I Replaced My 5-Year-Old Self-Built PC — and Ran a 125B Local LLM on an RTX 5070 Ti

Introduction
Weekdays I work; weekends I spend on my grad school research. The self-built PC I've been hammering away at from morning to night almost every day has finally started reaching its limits.
What triggered this was getting into running local LLMs. Once I seriously started using GPU inference, VRAM 8GB limits which models I can actually run. Even for gaming, I'm looking forward to the PC version of GTA VI that will probably come out around next year.
So, I replaced my PC for the first time in about 5 years. In this article, the first half looks back on my 5 years with the old PC, and the second half covers the new PC's build, model selection, and measured results.
1. Five Years with the Old PC
The old PC's specs were as follows.
- CPU: Ryzen 7 5800X
- GPU: GeForce RTX 3070 (VRAM 8GB)
- Memory: 32GB
Around September 2021, I bought the parts in Akihabara with a friend. It was my second or third year as a working adult, and the time when I could finally afford to buy my own desktop PC. It was my first self-built PC, and I put it together at home with guidance from a friend who was used to building PCs.

The side panel is covered in stickers. Microsoft, Linux, Git, Python, a sea otter from my study-abroad spot in Monterey Bay — the traces of these 5 years are left exactly as they were.

During the COVID era, I used a different PC from my company for work. I used this PC for all of my grad school (JAIST) research. Attending lectures on Zoom while opening PDF materials on another screen, and SSHing into the terminal to run experiments. It served me extremely well for that kind of use.
After I moved to Microsoft, it also took on the role of a secondary work PC, and I used it for customer deliveries. Holding meetings while sharing the customer's screen, opening build screens locally in VS Code and the like, and timing things on yet another screen. Weekdays for work, weekends for grad school — I used it hard almost every day, and it held up remarkably well.
One of the motivations for the purchase was Cyberpunk 2077 at the time. However, right after launch it wouldn't run properly due to issues on the game's side, and I could actually play it only around 3 years later, once the game ran properly.
There are regrets too. I never fully made the most of the RTX 3070. While gaming, usage would climb to around 90%, but normally it sat at around 5%, and even 4K playback on YouTube only pushed it to around 10%. It wasn't until I started running GPU inference for local LLMs that I can say I finally put it to full use.
As for the upgrade rhythm, I think replacing a PC about every 5 years makes sense each time a top-tier AAA game of that era comes out. This time too, on top of the local LLM use case, there's no small amount of anticipation for the PC version of GTA VI that will probably arrive around next year.
2. New PC Build and Selection Criteria
The new PC's configuration is as follows.
- CPU: Ryzen 7 9850X3D
- GPU: GeForce RTX 5070 Ti (VRAM 16GB)
- Memory: 64GB
- Storage: 2TB Gen5 SSD
The guiding principle is to lean toward workloads that use the machine's full power. I run workloads that consume the CPU, memory, VRAM, and SSD together locally, and leave to the cloud whatever should be left to the cloud. The use cases are personal vulnerability-assessment verification and research, writing, and so on.

With this build, the first issue that comes up is which local LLM to run. From here on, the story becomes about model selection.
3. Choosing the First Model: Why Flash-Next
There were two selection requirements.
- Requirement 1: It must be the best model that runs on this machine's specs
- Requirement 2: Ideally, it should be an abliterated (censorship-relaxed) version
Initially, on the morning of the same day, I had settled on an abliterated version of a 27B-class model as the first pick. By the evening, however, the plan changed, and the final decision was the following configuration.
- Inference engine: Strata
- Model: abliterated configuration of Qwen3.8-Flash-Next (a 125B-class MoE model)
- Quantization: Official ISTA GSQ-RCO, IQ3_S
The method for achieving the abliterated version is a bit unusual. The weights themselves are exactly the official ISTA GSQ-RCO (identical byte for byte), and onto that we apply a refusal-direction control vector extracted from huihui-ai's abliterated version at runtime using Strata's control vector feature.
The reason for dropping the 27B was simple: Strata is an MoE-only engine, so the dense 27B was out of scope. The requirement of "the best model for the specs + abliterated" is better satisfied by the 125B-class Flash-Next. Running a dense model would require a different engine, and since this time I narrowed the engine down to Strata, I aligned the model choice to match it.
4. The DeepSeek Saga
During the selection process, there was one unexpected development.
Originally, I planned to use DeepSeek V4.1-Flash (552B MoE) for heavy workloads. However, DeepSeek had been removed from the list of supported models in Strata 0.2.15. Support was explicitly documented only up to 0.2.13.
There were two options: roll Strata back to an older version, or install an older version alongside the current one.
As a policy, I decided to keep Strata on the latest version. There must be a reason why support was dropped, and I wanted to avoid reverting without understanding why.
I did consider installing an older version side by side, but stopped before doing so. Even when placed in a separate folder, the older version shared its settings and component storage locations with the current version, and I could not confirm that they could be isolated. I prioritized not breaking the current environment, so I passed on the side-by-side install.
As a result, the "heavy workload" slot ended up being filled by UD-Q4_K_XL, the heavier quantization from the same Qwen family.
5. Benchmarks: IQ3_S Deployment Results
I ran measurements on the new PC right after deployment. The conditions were as follows:
- Strata: 0.2.15
- Model: Qwen3.8-Flash-Next IQ3_S (ISTA version)
- Refusal-direction vector: Applied (file hash verified, application confirmed in logs)
- API: Responds only on 127.0.0.1
The results were as follows:
- Generation speed: 37.4–47.9 tok/s (short test. The engine's official reference value is approximately 53 tok/s)
- VRAM usage: Approximately 14.1 GiB
- Engine memory usage: Approximately 21.5 GiB
- Time from restart to response: 49.5 seconds
It fit neatly within the 16GB VRAM and 64GB memory budget. The 49.5 seconds from restart to response is a figure measured with cache present, so it is not a true cold start.
6. Comparing IQ3_S and UD-Q4_K_XL
Even with the same Qwen, the balance between speed and quality changes with the quantization level. I compared my daily-driver IQ3_S against the heavier UD-Q4_K_XL quantization on the same tasks.
| Measured on the same tasks | IQ3_S | UD-Q4_K_XL |
|---|---|---|
| Short tasks | 20.6 tok/s | 8.6 tok/s |
| Code generation | 28.2 tok/s | 11.3 tok/s |
| VRAM usage | ~14.6 GiB | ~15.0 GiB |
| Free memory | 20.9 GiB | 16.7 GiB |
Q4 is about 2.4 to 2.5 times slower on these two tasks. On the other hand, both got the answers right and the code passed its tests, so no difference in quality was visible. Note that VRAM usage measured right after installation was about 14.1 GiB, but in this comparison test it was about 14.6 GiB, so it varies slightly depending on the measurement conditions.
7. Results on a Harder Benchmark
I also compared them on harder tasks. The set consisted of 10 tasks: 3 math, 4 coding (including 1 multi-file debugging task), 2 reasoning, and 1 instruction-following task. For the publicly available problems, I used variants with the numbers and settings changed. Each task was run 3 times, for 60 trials total, which were auto-graded with no trials excluded. temperature was 0.6 for both configurations, under identical conditions.
The results are as follows.
- Average score: IQ3_S 7.0/10, UD-Q4_K_XL 7.67/10
- Average speed: IQ3_S 39.36 tok/s, UD-Q4_K_XL 19.82 tok/s
The gap in average score comes from a single math counting problem. On that problem, IQ3_S answered correctly 1 out of 3 times, while Q4 answered correctly all 3 times. On the remaining 9 tasks, both configurations produced the same results.
As a conclusion, I settled on IQ3_S for daily use, and Q4 as a second attempt on tasks IQ3_S gets wrong and for verifying important outputs. That said, this is a small-scale test of 10 tasks. We saw the potential for a gap on tasks like counting where accuracy matters, but it doesn't establish any overall superiority.
8. What a Local Model Can Do
Finally, let's look at this environment's capability from another angle. Here's a comparison in which the locally-run Qwen3.8 (IQ3_S) and the cloud-based Sonnet 5.5 were given coding challenges to solve. The measurements were taken by a separate AI agent.
First, the initial results for a challenge involving 2 files:
- Sonnet: 18 out of 18 passed, 36.8 seconds
- Qwen: 12 out of 18 passed, 54.0 seconds
What Qwen dropped were the 6 cases related to negative number handling. In this run, combining the spec with the previous output exceeded the 4k input window configured for the work session, so it was not possible to measure whether Qwen could make up the difference with corrections.
Next, a two-stage challenge with the task split into smaller pieces:
- First stage: Both models passed 9 out of 9
- Second stage: With the existing 9 cases maintained, both models also passed all 9 additional cases
- Second stage generation time: Qwen 77.7 seconds, Sonnet 18.5 seconds
Both models passed this without any corrections or retries.
In addition, on a separate test on the home lab's OpenClaw side using short Python challenges, both models passed. However, since this is a separate test with different conditions from the comparison above, the results are kept separate and not mixed. Also, in a prior set of 26 tests, Sonnet passed all 26, but there were problems with the challenge specification itself, and Qwen went unscored due to a 110-second time limit. These cannot be used to evaluate performance.
Here's how to read this. In this two-stage challenge, the local model passed all tests as well. Breaking the work into small stages is what made the difference. On the other hand, generation time was shorter for Sonnet, and in the 2-file challenge passed in one shot, Qwen had some misses. Since the conditions differ from test to test, we can't draw conclusions about general development capability rankings or long-running work quality.
As a supplement, since Qwen's output is generated locally, it does not consume Sonnet's usage quota. However, this is treated as a separate matter from the speed and quality comparison.
9. Integration with the Home Lab
Strata has an OpenAI-compatible API. I confirmed that it can be accessed from my home lab's Mac mini (the machine running OpenClaw).
I left the listener set to localhost without changing it, and exposed it through Tailscale, limiting access to my own tailnet only. I did not expose it directly to the internet.
10. Remaining Tasks
There is one thing I was unable to determine: the effect of abliteration, that is, the control vector.
The harmless test questions I prepared for verification were not rejected by the model even without the vector. Because of that, I was unable to obtain any material that would let me determine whether the vector has an effect or not. This remains a task for the future.
Conclusion
I migrated from the first self-built PC I used for 5 years to a new PC with a Ryzen 7 9850X3D and an RTX 5070 Ti.
In model selection, the fact that the engine was MoE-only and that DeepSeek support was dropped were unexpected, but in the end I settled on a two-model setup: IQ3_S for everyday use and UD-Q4_K_XL for heavy verification. In actual measurements, IQ3_S scored 7.0 points at about 39 tok/s and Q4 scored 7.67 points at about 20 tok/s, so the trade-off between speed and accuracy is visible in the numbers.
In the staged tasks this time, the local model passed all tests just like the cloud models did. The GPU that I couldn't fully utilize 5 years ago is now being pushed to its limits from the start.