#use-cases

The deep-dive on use-case #5. Classify, extract, summarize, or transform a pile of documents headlessly — running the model against a queue, not a chat. Where local AI's cost-at-scale argument actually bites, the throughput math, and the honest 'one stream at a time' limit.

The deep-dive on use-case #3. Wire a local speech-to-text model, a local LLM, and a local TTS engine into a voice assistant that works offline, has no wake-word corporation listening, and runs on hardware you own. Architecture, latency budget, and the honest '1–2 seconds' reality.

The deep-dive on use-case #2. Drop contracts, research dumps, or internal docs into a local RAG stack and the model reads, retrieves, and answers — with nothing leaving your disk. Architecture, model choices, the honest limits of local retrieval, and a working starting config.

The deep-dive on use-case #1 from '5 things you can do with a local LLM.' A working coding agent — refactors, tests, explains codebases — running on a local model, with your source never leaving your machine. Setup, model choice, where it's good, and where it falls down.

A working private chat assistant — model, web UI, and OpenAI-compatible API — running entirely on hardware you own, for the price of one card. The shortest path from zero to 'it works,' with the honest limits and where to go next.

Replicate, fal.ai, Midjourney, and OpenAI compared for cloud image generation. The billing models differ more than the models do — per-second, per-image, subscription, and token-bundled each win for different usage patterns. Here's the decision tree.

Cloud video generation has the widest price range in AI media — $0.13 to $3.20 per clip. Runway, fal.ai, Pika, and Sora compared on pricing models, quality, and content control, with a decision tree for which provider wins for which use case.

How to make ComfyUI actually fast on a card you can afford. Dynamic VRAM is the big 2026 leap, but the quantization and attention-backend choices matter as much. Here's what each optimization does, when it helps, and the honest trade-offs.

Running Wan, Hunyuan Video, and CogVideoX locally — what's actually runnable on consumer GPUs, what isn't, and the optimizations that help. The honest version, because video is where local hardware hurts most.

The local-vs-cloud question for AI image and video generation isn't 'which is better.' It's a cost, privacy, and volume calculation — and the answer is different from the one for text. Here's the framework, the break-even math, and where each side actually wins.

What it actually takes to run Flux and Stable Diffusion on your own GPU — VRAM floors by model, GPU picks by budget tier, and the five optimizations that make marginal cards viable. No 'best GPU' list — the math.

Not future use-cases — things you can set up this week on hardware you already own. Practical workflows, what they're good at, and where they fall down.