Your PC monitor shows numbers. It should understand your machine.
I wrote most of this article in the evening, after a day of welding plastics at a repair shop.
That's the honest setup. My savings ran out.
My IT applications stay silent. So three days ago I started a temporary job that has nothing to do with code, and I write this at night, the same rhythm this whole project was built in for 11 months.
But here's the part that keeps me going:
the thing I'm about to explain isn't a plan or a pitch.
It's working code in a free, open-source tool you can download right now and read line by line. Industrial-grade statistics, running on your PC, learning your specific machine.
Built by someone who codes between shifts.
Let me show you why every traditional PC monitor is fundamentally limited and what learning your specific hardware actually looks like in code.
The threshold is dumb by design
Open any popular system monitor and it does one thing:
draws 78°C on a graph. Red when it crosses 80. That's it.
It has no idea whether that 78°C is your idle on a hot July afternoon, or gaming on a cooler that's been collecting dust for six months. To the monitor, 78 is just 78.
The threshold is dumb by design.
That's not an insult but it's its nature.
Rule
"if temp > X, alert"
has no concept of what it's running on. It doesnt remember yesterday.
It doesn't know your RTX always holds 71°C in this game, and today it s*uddenly hits 77 at the same load in the same room*.
The threshold only sees a number against a constant somebody hardcoded for every machine in the world at once.
And here's the most important sentence in this article:
your machine isn't in any table.
How these tools actually work
Before anyone says "but I have Afterburner and it's great" — sure, it is.
Let's just look at what it actually does under the hood.
And what the others do, because each one is excellent at one thing and blind in another.
MSI Afterburner / RivaTuner:
a hand-drawn fan curve (lookup table) and a fixed clock/voltage offset.
Zero learning. The curve is a table.
"Set and forget" OC doesn't know about silicon aging or ambient temperature.
Fan Control / Argus Monitor:
highly configurable, but still rules and triggers that YOU define.
You are the intelligence. The program just executes.
HWiNFO / HWMonitor: the gold standard for raw sensor data.
Zero recommendations, zero memory. Pure readout.
CCleaner: deletes temp files and "cleans the registry".
Registry cleaning is a 2026 myth, Microsoft itself advises against it, performance gain is roughly zero.
GeForce Experience / Armoury Crate / iCUE:
cloud database of GPU+game, presets by hardware category.
A profile for "RTX 4070," not for your specific card or your temperatures. Phones home.
Notice the pattern.
Every one is a different way to do the same two things:
show data, or execute a rule somebody set in advance.
None of them builds a model of your computer.
At best, you are the intelligence, sitting there setting curves by hand.
At worst, the cloud is the intelligence, it knows you have an "RTX 4070" and has no clue your specific unit runs 6 degrees hotter than your neighbor's with the same SKU.
Four reasons "general" is weak
Silicon lottery.
Two identical RTX 4070s from the same production line aren't identical.
Different voltage-frequency curves, different leakage, different undervolt headroom. Gap can reach 50-100 mV.
That forum advice "for a 4070 do -100 mV, works for me" will crash half the units to a black screen, because half don't have that headroom.
A general profile physically cannot know your silicon.
It saw an averaged card you don't own.
Aging and drift.
Thermal paste pumps out over a year or three, and temperatures climb a few degrees. Fan bearings wear. PSU capacitors age and lose capacitance.
A fixed profile never adapts, because it was written once.
Your "stable" OC from last year throws silent soft-errors today.
Ambient and context.
The same load at 18°C in winter and 28°C in summer produces different core temperatures.
"if temp > X"
rule is blind to this. It doesn't know your room, the season, or that you opened a window.
Load composition.
"Game + Discord + browser + OBS" is a completely different thermal profile than the game alone.
A Blender render (sustained 100% for an hour) behaves differently than a game (bursty spikes) and differently than a crypto miner (pegged full).
General thresholds treat load as if it exists in isolation.
In real life it never does.
Voltages. This is where it all comes together.
If you remember one example from this article, remember this one.
The ATX spec for the 12V rail allows ±5%. So anything from 11.4V to 12.6V is formally "within norm".
Every classic monitor only alerts you once voltage leaves that band.
But a healthy PSU doesn't float across that whole range.
A healthy PSU holds your rail much, much tighter, around 11.95-12.05V. That's a real ±0.4%, not ±5%.
Now: your PSU starts aging.
Under load the rail drops to 11.7V.
Still "in spec"! The threshold says OK, you're fine.
But those are tired capacitors making themselves known, months, sometimes half a year before the system starts failing under heavier load.
This is where statistics computed on your history come in, not on a spec sheet.
PC Workman keeps the median and MAD (median absolute deviation) of your own samples and computes a modified Z-score per Iglewicz-Hoaglin:
M = 0.6745 × (x − median) / MAD
|M| > 3.5 → anomaly
|M| > 2.5 → warning
A drop to 11.7V, invisible to the ATX threshold, runs well past 3.5 against your own 11.95-12.05V norm. Anomaly.
An early warning no threshold on earth catches, because the threshold looks at the manufacturer's spec, not at how this specific PSU behaved over the last few weeks.
Why median, not mean? Because the mean is a coward.
One voltage spike drags the mean up, widens the band, and the next spike passes without an alarm, the tool anesthetizes itself.
The median doesn't move after one outlier.
MAD inherits that robustness.
Add four Nelson Rules (single spike, 2-of-3 cluster, nine points on one side, six-point monotonic trend), that's classic Statistical Process Control, the same kind factories have used to watch production lines for decades.
I'm not reinventing the wheel.
I moved proven process control onto your PC's power rail.
That's the whole thesis in one picture: an absolute spec threshold versus statistical control against your own history.
Wait, "AI," meaning what exactly?
I have to say this plainly, or the whole article goes in the trash with the marketing nonsense:
"AI" here does not mean a chatbot bolted onto an old tool.
There's no GPT stapled on that "intelligently analyzes your hardware" and in practice makes things up.
Underneath sits real statistics: **Welford's **algorithm for online mean and variance (one pass, no keeping the whole history in RAM), median and MAD for voltages, Nelson Rules, process control.
These are methods from the '60s and '90s, boring, predictable, and that's exactly why I trust them.
Statistics don't hallucinate.
When someone says "AI in a monitor," 95% of the time it means
"we pasted in an API and now it costs more".
Here it's the opposite, the model learns locally, on your data, with no account and nothing sent anywhere.
The six lines that start it all
The whole context-aware system begins with one tiny function. This is the actual code:
def classify(self, cpu_pct: float, gpu_pct: float) -> str:
if gpu_pct >= 60: return "gaming"
if cpu_pct < 15: return "idle"
if cpu_pct < 35: return "light"
if cpu_pct < 65: return "medium"
return "heavy"
Five contexts: gaming, idle, light, medium, heavy.
That's the secret.
Once the system knows the context, it learns what "normal" means inside it.
Not normal in general.
Normal for your machine, doing what it's doing right now.
Each snapshot lands in one of five buckets, and each bucket keeps its own learned baseline using **Welford's **online algorithm over your last 14 days of history.
An 80°C threshold for everything is lazy.
72°C while gaming on a mid-tower is fine.
The same 72°C while idle on a thin laptop means something is wrong.
Where it actually beats the threshold
Predictive maintenance, the killer feature.
Voltage drift caught by MAD and Nelson Rules means tired capacitors.
A systematic +3-5°C climb over weeks means paste needs replacing, caught before the CPU throttles.
Falling RPM-to-temperature efficiency means dust in the heatsink.
Catching problems before they become problems.
A threshold can't do this by definition, it waits until things are already bad.
Root-cause throttling instead of "CPU hot".
A general tool says: 95°C, a lot.
The model says: 95°C, but only during game+render, and that's +6°C above your 30-day norm for this specific load, most likely dust or paste, here's the trend chart, see for yourself.
The second answer contains a cause.
The first is just a number with an exclamation mark.
Anomaly as security. A process pretending to be svchost.exe but launched from %TEMP%.
An unusual CPU pattern that looks like a quiet miner.
Pattern-against-your-norm catches things a signature list doesn't know, because you don't need to know the threat's name, you just need to know this machine never behaved like this before.
The analogy that closes it
Whoop and Garmin don't tell you
"your resting heart rate is 60, norm is 60-100, you're OK".
They learn your resting HR and HRV, and alert when you drift from your baseline, even if you're still within "population norm".
That's how they catch something happening a day before you feel it.
PC Workman is exactly that, for your computer.
"78°C" without your baseline is like a heart rate of 100 without knowing whether you're looking at a marathon runner after training or someone who just climbed to the second floor out of breath.
Same number, two completely different worlds.
The whole difference is context — and a threshold has none.
Honestly: where this has limits
I won't sell you this as magic, because it isn't, and a text pretending its product has no flaws disqualifies itself.
Cold-start. Fresh after install,
the model doesn't know your norm yet, it has to gather data for weeks, realistically 6-12 months, to pass through summer and winter, gaming and idle, different loads.
During that time it's closer to a regular monitor than an intelligent one. That's the price of later talking about your hardware instead of an averaged one.
It needs good sensors, and Windows can really make you suffer here.
psutil.sensors_temperatures() returns an empty field on Windows, no temperatures, the end, thank you.
Hence the dependency on LibreHardwareMonitor and WMI just to have something to learn from. I know this not from documentation but from tripping over it myself and losing an evening before I understood why the voltage chart was empty.
It must not bark without reason.
One false alarm now and then and you stop trusting the tool, you turn off notifications and that's that.
So 12V spikes during GPU load changes are deliberately suppressed
(they're physically expected, not a failure)
and a pattern that repeats five times stops being treated as an anomaly and becomes your hardware's new norm.
A*nomaly decay.*
A tool that learns must also know how to retract its own alarm.
And one more thing, to be clear:
this is not anti-HWiNFO or anti-Afterburner. Raw sensor data is still the foundation everything stands on. What changes isn't that you read the data, it's what happens to that data next.
Why I'm telling you this between welding shifts
Your computer has a history. Specific, physical, its own, that one piece of silicon in that one room with that one PSU.
It's time a program remembered it, instead of comparing you to an average you never owned.
I built this because I got tired of tools that show and never understand. I built it on a laptop that hit 94°C, between warehouse shifts in the Netherlands, then between convenience store shifts in Poland, and now between welding shifts at a repair shop.
Monday, an article about this project hit #1 Trending on HackerNoon.
My first thought wasn't "I made it".
It was "what if this is an accident?"
Fear after success is stranger than fear after failure, with failure you know what to fix, with success you suddenly have something to lose.
But the code doesn't know I'm scared. It doesn't check trending positions.
It classifies the context and keeps learning. Maybe that's the lesson.
We stopped needing a tool that shows. We need one that understands,
and does the work for us.
Locally. Quietly.
This isn't a roadmap, it's working code.
Thermal Baseline Learning and Voltage SPC described above run in
PC Workman v1.7.9 - free, open-source. You can check every line.
Download or read the code:
github.com/HuckleR2003/PC_Workman_HCK
Full article on the project domain site!: pcworkman.dev
Everything else and coffee! :) : linktr.ee/marcin_firmuga
About the Author
I’m Marcin Firmuga. Solo developer and founder of HCK_Labs.
I created PC Workman, an open-source, AI-powered PC resource monitor who learns, after time, your natural PC behavior (spikes, voltage, temps, usages) built entirely from scratch on dying hardware during warehouse shifts in the Netherlands.
Before this: game translations, PC technician internships, warehouse operations in multiple countries, and countless failed projects I never finished.
But this one? This one stuck.
1000+ hours of code. 4 complete UI rebuilds. 16,000 lines deleted.
3 AM all-nighters.Energy drinks and toast.
And my own hck_GPT AI, building for months to give a PC Workman a brain and heart.
And finally, an app I wouldn’t close in 5 seconds. That’s the difference between building and shipping.
Marcin Firmuga | 22 | Poland | HCK_Labs Building PC Workman publicly. Physical work by day, code by night.
Marcin Firmuga | 22 | Poland | HCK_Labs
Building PC Workman publicly. Physical work by day, code by night.
Top comments (0)