
Guides / Computing costs and local AI
We turned two retired Samsung phones into always-on Linux servers
Two old Samsung phones become headless Termux Linux servers: SSH, auto-start on boot, a day-zero hardware baseline, and why memory bandwidth decides the rest.
Engineering note
Filed by the Office of Steampunk DevSecOps, our fictitious department for salvaged hardware, free-token pressure tests and moving work between our own machines and the cloud. About the office
In part 1 we benchmarked a desktop with no graphics card. In part 2 we turned a 2017 iMac into an Ubuntu server. In part 3 we split one model across both machines and found that memory bandwidth, not clock speed, sets the ceiling. This part brings in the two devices the series kept promising: a Samsung Galaxy S10 from 2019 and a Galaxy Z Fold 6, both headed for a drawer. They came back out as servers.
What this part shows: both phones can become real headless Linux boxes — wiped, account-free, reachable over SSH from another phone, and set so SSH comes back on its own after an Android reboot — without unlocking or rooting a thing. We could not replace Android with desktop Linux (the bootloaders are sealed shut), so we ran Linux inside Android instead. Then we took a careful day-zero baseline. We have not run a language model on them yet; what they are for is the next experiment, and the numbers below are why we are taking it slowly.

Why phones, and why now
Here is the twist the series keeps handing us: the best return has not come from local AI at all. It has come from GitHub-hosted build runners, which cut our projected November spend sharply against October. So the phones are a cheap curiosity, not a rescue plan — and that is exactly why a sober baseline beats a flashy demo. The question is not "can a phone run AI." It is whether two devices we already own can earn a small, honest job on the home network, and the only way to answer that is to measure before we assume.
The dead end worth documenting
Plan A was to erase Android entirely and install postmarketOS, a true mobile Linux. It never got off the ground. Flashing a new operating system needs an unlockable bootloader, and both phones are US Snapdragon models on which Samsung locks the bootloader for good — there is no OEM unlocking switch to turn on, which also rules out rooting.
So here is the practical finding: for these two US Snapdragon models, on the firmware they shipped with, we found no supported bootloader-unlock or rooting path. A sealed bootloader blocks the official custom-image and rooting routes; we are not claiming no exploit could ever exist, only that there is no supported way in, and the old paid-token trick for this S10 was closed years ago. The way in is not under the hood — it is Termux, an app that gives you a genuine Linux shell, package manager and SSH server on stock, locked, un-rooted Android, with no account required.
Turning each phone into a server
The recipe was identical on both, and after the first few minutes we ran all of it over SSH from a third phone, screens dark:
- Reset and lock down. Strip every Google and Samsung account, pull the SIM, join Wi-Fi only, and switch the telemetry toggles off. Turn the charge limit on — 85 % on the S10, 80 % on the Fold 6 — because sitting at 100 % on a charger can accelerate battery aging and raise the risk of swelling; a cap reduces the stress, it does not eliminate it.
- Install Termux from F-Droid, then
pkg install openssh, set a password, and startsshd(it answers on port 8022). - Reserve a fixed IP for each phone in the router, so they always come up at the same address.

Making them survive a reboot
A server you have to babysit is not a server. Two Android instincts fight you: the system sleeps idle apps, and nothing restarts after the power blinks. We beat both — a wake-lock plus "never sleeping apps" keeps it awake, and the Termux:Boot add-on runs a three-line script at power-on that grabs the wake-lock and launches sshd.
Then the test that actually matters. We rebooted each phone and, without touching it, reconnected from the control phone a minute later. Both dropped us straight at a shell prompt. The chain we tested — Android reboot, then wake-lock and SSH on its own — ran unattended. One honest caveat: Termux:Boot only fires once the phone is unlocked, and because these phones carry no screen lock they boot straight to ready; add a PIN and you would have to unlock after every reboot. We tested a reboot, not a full power loss — a phone that shuts down on a dead battery and waits for the charger is a case we have not checked.
The day-zero baseline
Before installing a single model, we measured the bare hardware with a small script that leans only on tools already in Termux. The number that governs local AI is memory bandwidth, measured here with a STREAM triad test — because generating text on a CPU means hauling the entire model out of memory once per token. (Memory is quoted in GiB, gibibytes of 1024³ bytes, the way Linux counts it.)
| Measurement | Galaxy S10 (Snapdragon 855) | Galaxy Z Fold 6 (Snapdragon 8 Gen 3) |
|---|---|---|
| Android | 12 | 17 |
| RAM total / free | 7.3 GiB / ~4.5 GiB | 10.9 GiB / ~7.6 GiB |
| Memory bandwidth, all threads | 18.7 GB/s | 28.4 GB/s |
| Memory bandwidth, one thread | 19.9 GB/s | 9.3 GB/s |
| Disk write | 188 MB/s | 1.6 GB/s |
| Wi-Fi ping to router | 15.8 ms | 42.3 ms |
Two things stand out. In this short write test the Fold 6 wrote about 8× faster than the S10 — a hint it would pull large files off storage quicker, though we did not measure actual model-load time. The memory-bandwidth story is the more interesting one. On the S10, the all-thread run was no faster than the single-thread run — we saw no gain from more threads in this comparison, which is what you would expect if one thread already keeps its memory controller busy. The Fold 6 climbed from 9 GB/s on one thread to 28 across four. One caveat on those thread counts: nproc reported four or five of each phone's eight cores for this run — an availability count at that moment, not a permanent per-app limit.

What the numbers mean, and what they don't
Here is some back-of-envelope arithmetic — and please read it as exactly that. Divide this run's triad bandwidth by a model's weight size and you get a rough bandwidth budget: on the Fold 6, about 14 tokens per second for a 4-bit 3-billion-parameter model (~2 GB of weights) and about 6 for an 8B (~4.5 GB); on the S10, about 9 and 4. These are arithmetic estimates from one STREAM result, not measured inference rates or proven limits — real kernels, quantization, cache traffic, context length and compute can all move the number. We have not run a language model on either phone; a proper benchmark is what will give true figures.
So these are light-worker machines, not pocket GPUs. Whether that light work should be small models, a build or monitoring node, or something else entirely is genuinely open — and the reason we took the baseline first is so the answer can rest on measurement instead of hope. With our build runners still the better bargain, we are keeping the bar where it belongs.
What we have not tested: any language model, a wired connection, a full thread-count sweep across all eight cores, recovery from a dead battery rather than a reboot, or how either phone behaves after hours of sustained load and heat. Those come next — if, and only if, the phones earn a real job.
Sources
- Termux: a terminal emulator and Linux environment for Android, installed from F-Droid (no root required). f-droid.org/en/packages/com.termux/
- postmarketOS: a Linux distribution for mobile devices; its device table lists which phones can be flashed. postmarketos.org/
- McCalpin, John D. STREAM: a synthetic benchmark program for sustained memory bandwidth (the triad kernel used here). www.cs.virginia.edu/stream/