I Built My Entire Personal AI Stack for $0 in API Costs — Here's What's Running on My Mac Mini Right Now

This week, ggml.ai officially joined Hugging Face to ensure the long-term progress of local AI. If you have been watching this space for the past year, you know this is a massive deal. The library behind llama.cpp — the tool that made running LLMs on consumer hardware a reality — now has the backing and infrastructure of the largest open-source AI platform on the planet.

When I read the announcement, I realized I should write up what I have actually been running at home. Because my personal AI stack costs exactly zero dollars per month in API fees, and it does more than most people think is possible with local hardware.

---

The Hardware: One Mac Mini, Always On

My entire setup runs on an M4 Mac Mini sitting next to my TV. No monitor, no keyboard, no dramatic server rack. It draws about 5 watts at idle, stays completely silent, and handles everything I throw at it.

The M4's unified memory architecture is the key. With 32GB shared between CPU and GPU, I can run models up to 20 billion parameters without any quantization tricks. The neural engine handles inference efficiently enough that most responses arrive in under two seconds.

Total hardware cost: the Mac Mini itself. Monthly operating cost after that: electricity. Which, for a device that draws less power than a light bulb, is negligible.

---

Layer 1: Ollama — The Foundation

Everything starts with Ollama. It is the runtime layer that makes local LLMs feel like API calls. I keep three models loaded and ready:

• gpt-oss:20b — My workhorse for code generation, test case writing, and complex reasoning
• llava — Multimodal model for screenshot analysis and visual element grounding in my self-healing QA agent
• nomic-embed-text — For local embeddings powering semantic search across my notes and documentation

The beauty of Ollama is that it exposes a local API endpoint at localhost:11434 that is compatible with the OpenAI client format. Every tool I build can swap between local and cloud models by changing a single environment variable. No code changes required.

With ggml.ai now under the Hugging Face umbrella, the quantization and optimization pipeline feeding Ollama is only going to get better. More efficient models, better memory management, broader hardware support. The local AI ecosystem just got its strongest foundation yet.

---

Layer 2: Personal Learning Experiments

AI Test Case Generator (Local Mode)

My AI Test Case Generator is an educational research project that runs in dual mode: Gemini for the cloud-hosted demo, Ollama for local development. When I am iterating on prompt engineering or testing new requirement document formats, I run everything locally. The feedback loop is instant, there is no rate limiting, and I can experiment freely without watching a billing dashboard.

The local mode processes PDF uploads, extracts requirements, and generates structured test cases in both Standard Table and Gherkin formats — all without a single external API call.

Self-Healing QA Agent

The personal research project I am most proud of runs entirely on local infrastructure. My Playwright + MCP + Ollama agent uses the llava model to perform visual element grounding when standard selectors fail. It looks at screenshots, understands what is on the page, and generates new locators automatically.

This is the workflow: Playwright tries a selector. If it fails, MCP captures a browser snapshot. Ollama's llava model analyzes the screenshot. The agent generates a new locator and retries. All of this happens locally, in seconds, with zero API costs.

I have been running this against my portfolio site for months. When I push UI changes, the tests heal themselves. The total cost of that self-healing capability: nothing.

Agentic Appium with LangGraph.js

My mobile automation framework uses LangGraph.js to orchestrate an Observer-Reasoner-Executor loop with Ollama as the reasoning engine. When a mobile UI element moves or changes, the vision model finds it visually instead of relying on brittle accessibility IDs.

The entire state graph — observation, reasoning, action selection, execution — runs on the Mac Mini. I have tested it against iOS Simulator sessions running simultaneously on the same machine. The M4 handles both the simulator and the LLM inference without breaking a sweat.

---

Layer 3: Personal Automation

Beyond the QA-specific projects, I run a personal automation layer powered by OpenClaw. My AI agent handles daily tasks — checking emails, monitoring calendars, running periodic health checks on my deployed projects — all through a single Telegram interface.

The agent itself uses Claude through a flat-rate subscription. But every tool it calls locally — the search embeddings, the code analysis, the test execution — runs through Ollama. The hybrid architecture means I get frontier-model intelligence for conversation and reasoning, paired with local execution for everything that touches my code and data.

---

Why Local AI Matters More Than Ever

The ggml.ai and Hugging Face merger is not just an organizational change. It is a signal that local AI inference is becoming critical infrastructure, not a hobbyist curiosity.

Here is what running everything locally gives you:

• Privacy: Your code, your test data, your requirements documents never leave your machine
• Cost predictability: No surprise bills, no rate limits, no usage tiers
• Speed: Local inference on Apple Silicon is faster than most cloud round-trips for models under 20B parameters
• Reliability: No outages, no API deprecations, no breaking changes from upstream providers
• Experimentation freedom: Try anything, as many times as you want, without cost anxiety

For QA engineers specifically, this changes the economics of AI-powered testing. Self-healing tests, AI test generation, visual regression analysis — all of these become free to run once you have the hardware. The barrier to entry is a machine you might already own.

---

Getting Started This Weekend

If you want to replicate this setup, here is the minimal path:

1. Install Ollama: curl -fsSL https://ollama.com/install.sh | sh
2. Pull your first model: ollama pull gpt-oss:20b
3. Verify it works: curl http://localhost:11434/api/generate -d '{"model":"gpt-oss:20b","prompt":"Hello"}'
4. Build something: Point any OpenAI-compatible client at http://localhost:11434/v1 and start coding

You do not need a Mac Mini. Any machine with 16GB+ RAM can run 7B models comfortably. 32GB opens up the 20B range. The M-series Macs are ideal, but Linux boxes with decent GPUs work perfectly too.

The local AI stack is not the future anymore. It is what I am running right now, today, for free.

---

Suneet Malhotra is an AI-Driven Quality Engineering Leader with 20+ years of experience. He writes about agentic systems, test automation, and building software that actually holds up. Connect on X/Twitter or LinkedIn.