Like many engineers experimenting with local AI, I initially assumed one thing:
If you want to run a capable LLM locally, you need an expensive NVIDIA GPU.
Every YouTube video, benchmark, and Reddit thread seemed to point in the same direction — RTX 4090, RTX 5090, multiple GPUs, or don’t even bother.
So before spending over £1,000 on a graphics card, I decided to run a simple experiment.
Could a £400 BOSGAME mini PC with an AMD Ryzen 5 7640HS, 32 GB DDR5 RAM, and integrated Radeon 760M graphics run gpt-oss:20b well enough to build a real AI application?
The answer genuinely surprised me.
The hardware under test
| Spec | What I used |
|---|---|
| Machine | BOSGAME mini PC (~£400) |
| CPU | AMD Ryzen 5 7640HS (6 cores / 12 threads) |
| GPU | Integrated Radeon 760M |
| RAM | 32 GB DDR5 |
| Storage | NVMe SSD |
| Stack | Ollama, Docker, Open WebUI, agents, APIs |
| Model | gpt-oss:20b (quantised, local) |
My goal wasn’t a chatbot
I wasn’t interested in asking an LLM random questions.
I wanted to build something useful.
In my case, that meant creating a fully local AI trading agent capable of:
- Analysing market data
- Making structured trading decisions
- Returning valid JSON
- Calling external APIs
- Running 24×7 without cloud costs
- Keeping all data local
That is very different from simply measuring tokens per second.
The biggest problem wasn’t performance
After getting everything running, I realised something interesting.
The hardware wasn’t the biggest challenge.
The model was fast enough for my use case.
Instead, I spent far more time solving problems like:
- Inconsistent JSON responses
- Prompt engineering
- Function calling
- Context management
- Model parameters
- Reliability across multiple requests
In other words…
Engineering the system became more important than buying faster hardware.
Modern integrated graphics are better than most people think
Would I train a 70B model on this machine?
Of course not.
Would I serve hundreds of concurrent users?
Probably not.
But for a personal AI assistant, automation workflows, API orchestration, or intelligent agents, the experience was much better than I expected.
The integrated Radeon 760M proved perfectly capable of running a quantised 20B model for practical development work.
Cost changes everything
One thing that often gets overlooked is total cost.
For roughly the price of a mid-range GPU, I bought an entire computer that now runs:
- Ollama
- Docker
- Open WebUI
- AI agents
- APIs
- Databases
- Development tools
And because it’s a complete machine rather than just a GPU, it stays powered on all day, quietly consuming a fraction of the electricity of a gaming desktop.
For a home AI lab, that’s a huge advantage.
You don’t always need an expensive GPU to build powerful AI applications. Sometimes, engineering > raw compute.
Benchmarks don’t tell the whole story
We spend a lot of time comparing:
- Tokens per second
- VRAM
- FLOPS
- Benchmark charts
Those numbers matter.
But they don’t tell you whether you can actually build a reliable AI application.
In my experience, factors like prompt design, inference settings, model choice, and orchestration had a much bigger impact than another 20–30 tokens per second.
Would I still buy a GPU?
Yes — if I were:
- Training models
- Running 70B+ models
- Serving multiple users simultaneously
- Chasing maximum throughput
But for developers building AI copilots, integrations, automation platforms, or personal agents, I think modern mini PCs deserve far more attention than they receive.
Final thoughts
This experiment completely changed how I think about local AI.
The conversation shouldn’t start with:
“Which GPU should I buy?”
It should start with:
“What problem am I trying to solve?”
For me, a £400 BOSGAME mini PC with an AMD Ryzen 5 7640HS turned out to be more than capable of running gpt-oss:20b and powering the kind of AI agent I wanted to build.
Sometimes, the biggest limitation isn’t the hardware.
It’s how well you engineer the system around the model.
I’m now experimenting with different inference engines, structured output techniques, and agent frameworks to make local models even more reliable.
Have you tried running a serious local LLM without a dedicated GPU? I’d love to hear what hardware and models you’re using — drop a note via Topmate or LinkedIn.