What people do
for real with local.

A teacher runs an entire exam-correction pipeline on a single 3090, from generating answer sheets to scoring hundreds of students automatically.

Confidentiality obligations, not a specific incident, are enough reason for this lawyer to do all document review and drafting locally.

A cycling and running coach runs client-facing coaching assistance on a small DGX Spark cluster, good enough for national-champion-level clients — at a cost the coach openly questions.

Switching from llama.cpp to vLLM on AMD hardware was the unlock for running a complete SaaS build loop through a local model.

A cloned five-store e-commerce operation — cart, mailings, WhatsApp login, payment gateways — runs day to day on a single 7900XT, turning a real monthly profit.

Beyond the obvious coding use case, this setup handles website debugging, deep web research, and day-to-day Linux server maintenance.

This person is building an ingestion pipeline that reads their documents and mail and auto-creates follow-up todos, alongside using local models for questions they don't want tied to their identity.

Qwen 27B and the Pi coding agent built a custom chat UI, an mp3 server, and a homelab control panel — and did the desktop tidy-up that first proved the setup was worth keeping.

Using Hermes to patch DeepSeek to a vision release and then move the whole agent, containers, and environment to another computer — remotely, from a phone.

About a year into daily local use, this setup covers private coding projects and a broader life-assistant role: web search, journal access, and photo access.

This person knows Qwen 3.8 Flash Next on two DGX Sparks can't match frontier intelligence, and says that's not really the point for them.

Not vibe coding: a custom harness on a patched llama.cpp build has shipped seven real KMP projects.

Client confidentiality rules out cloud APIs for this freelancer, who spreads different model sizes across three separate machines.

Cron jobs and document review through Hermes, with files kept on a NAS behind a one-way mirror so a bad run can't take real data with it.

Running Qwen 3.8 27B on the same Mac they work on, this developer credits per-feature domain glossaries and tight scoping — not the model — for making local coding reliable.

A detailed personal checklist for getting a local setup to a genuinely reliable state — quant choice, inference engine by OS, and only then, real tasks.

Rather than one big general model, this setup uses several small, fast ones for narrowly scoped, deterministic jobs — starting with OCR and metadata for a self-hosted Paperless document server.

The same low-key homelab setup also runs a semi-agentic wedding planner that reads email, keeps a running database and document trail, and answers questions about where things stand — plus a separate loop that just deletes marketing mail.

Part of a hybrid RAG setup spanning a Mac Studio, a MacBook, GCP, and OpenRouter, with an unrestricted local model used specifically for questions frontier chat products decline to answer.

A local model ran fine, but between electricity, a maxed-out machine, and cloud models costing a few euros a month, the math didn't work out.

A four-bit Qwen 3.8 quant at 200K context handles complete app builds through OpenCode, left running until it hits a decision point.

Compliance, not preference, rules out any cloud infrastructure for this cybersecurity researcher's day-to-day binary analysis.

Local models take over the reading and summarizing side of manual stock analysis, cutting a research routine from hours a day to a few hours a week.

Qwen3-Coder through Cline writes the app; a paid ChatGPT Plus subscription reviews the prompts and the output before it ships.

Two 12GB 3060s handle both code review and customer-support lookups, reasoning read-only over live account data and internal docs.

This company believes uploading user data to a cloud model would be illegal for their use case, so email and user-text automation runs on a Gemma 4 build on a single Radeon Pro AI R9700.

This person kept paying for Claude Max specifically so they'd have a real comparison point for their own coding hardware — and admits the math still doesn't favor local.

A router in front of compiled llama.cpp servers, feeding Qwen 3.8 27B through OpenCode with downloaded skills, worked essentially out of the box.

Proving out AI tagging and logging for a media archive on one of the smallest cards in the thread, then building toward a self-hosted digital asset manager.

A phone app scans a receipt, a Synology NAS notices the new file and wakes the desktop, and a local model turns it into structured spending data — no manual step in between.

Local models here don't replace a cloud subscription so much as complement it — handling the smaller, more private slice of the workload.

Turning clinical notes into medical reports is privacy-sensitive enough that this person built a dedicated local skill for it rather than risk a cloud tool.

DevOps work, smart-home control, and paperwork all moved off the cloud once Strix Halo hardware arrived — with one exception the poster caught themselves forgetting.

A local model reads financial reports across 1,500 companies first, so the more expensive hosted model only has to work with the distilled output.

A short but clean division of labor: a frontier model decomposes work into tickets, and a local Qwen model implements them on production code, daily.

One small model does double duty: correcting speech-to-text output and acting as the decision-making 'brain' for home automation triggers.

On a VRAM-constrained 5070 Ti, this person keeps local strictly in the 'learning and playing around' lane, and routes actual work through Claude with local models as a validation step at most.

DeepSeek V4 Flash Vision on two DGX Sparks, wrapped in a heavily extended Pi Agent setup, handles nearly all of this person's hands-off work.

A large enterprise deployment: eight A100 80GBs running Qwen 3.8 under SGLang with tensor parallelism, while the company brings newer B200s online for bigger models.

Beyond personal daily use, this person stood up a Spark cluster for a client so their employees get an internal, compliance-friendly LLM platform.

A loop over a large, undocumented codebase asked a local model to summarize each function in a strict word limit, then wrote the result back as a header comment.

On a 12GB 5070, a heavily quantized Qwen 3.8 27B through a custom Hermes backend is, in their words, the first local model that's felt confidently productive.

Qwen 3.8 kept spiraling into overlong, indecisive reasoning on this person's coding tasks, no matter the configuration — so they moved back to Qwen 3.6.

An unusual layered setup: the local model isn't the coding agent — it's the thing an outer coding agent uses to build and stress-test a separate 'inner' agent.

A frontier orchestrator dispatching work to a local Qwen 3.8 27B subagent makes longer, harder jobs safe to hand off — but this person draws a hard line at giving any LLM unsupervised control of local files.

A NUC12 with a 16GB Intel Arc A770M handles a 262K-context Qwen build entirely in VRAM, coding in the background while the owner does something else.

A Python collector pulls read-only configs, firewall rules, and network health data every day and feeds it into a local RAG pipeline, so the advisor always knows the current state of the homelab without ever being able to touch it.

Hermes on Qwen 3.6 35B-A3B runs this person's entire homelab k3s cluster hands-off, including diagnosing a flaky network cable before it was told to.

A custom middleware layer that keeps an LLM-maintained wiki from decaying replaced this person's Google NotebookLM RAG setup entirely — and every cloud subscription along with it.

Playing a detective in a large GTA V roleplay server, this person used a local model to turn thousands of in-game arrest reports and applications into structured criminal profiles.

A vision model on a modest 3070 turns raw detection events from a home-built surveillance system into plain-language descriptions.

The same Qwen 3.8 27B instance that drives this person's Hermes agent also sits as an MCP tool for Codex, reviewing its proposals and its final output — and the task simply stops if the two can't agree.

After trying Claude Code with task-farming and a Qwen-as-orchestrator experiment, this person settled into two parallel workflows — Orca as the local workhorse, and OpenCode or Bionic for solo agent development.

Local transcription and summarization save real money at work, but this person draws a firm line at using local models for coding — even the newest ones.

Referral triage that extracts details, standardizes them, and suggests categories and tests — with the final call always left to a doctor, and nothing ever leaving the network.

Daily local coding on a 4070 is explicitly not as good as Claude for complex refactoring — but the privacy and iteration speed still make it worth keeping.

A vibe-coded Mac app uses OCR and vision to rename and file sensitive documents by local rules, running only after a faster, non-AI tool has already taken its pass.

Before anything reaches a frontier model, a local pass screens it first — for example, checking with high confidence whether an email is non-confidential enough to triage externally.

Purpose-built tools around a personal research corpus, plus Hermes as an interactive research assistant, get this researcher roughly 80% of the way to frontier quality — locally.

Countering a cost complaint elsewhere in the thread, this person runs agents on genuinely low-spec, CPU-only hardware and reports about 30 cents of electricity for a full day.

One of the only mobile setups in the thread — used daily on a phone as an offline-capable stand-in for search and reference lookups.

Weighed building a dedicated inference box against just paying for cheap cloud models — for now, cloud wins for anything demanding, while a laptop's integrated graphics handles the light stuff.