Rent the Brain, Own the Muscle
The reflex, when there is real AI work on the table, is to point the priciest frontier model at every step and pipe every audio file into the fanciest hosted API. It feels professional.
It feels like paying for quality. Then the bill arrives.
Here is a real job I ran this week. Product anonymized, numbers exact, receipts included.
The Job
A hardware brand hired me to find 150 creators worth pitching. Not “buy a list”. Actually understand who was worth reaching. For every account that meant: pull recent posts, pull audience comments, listen to what the creator says on camera, decide if they are relevant, then draft a personal opener that quotes a specific video and a real comment.
The volume shook out like this:
56 hours of speech had to become text. That is the number that decides the architecture.
The Split
Two kinds of work. Two kinds of compute. I split them by what each machine is good at.
┌─────────────────────────────────┐
│ ORCHESTRATION (rented cloud) │
│ Claude Opus 4.7 = the brain │
│ writes code, picks tools, │
│ debugs weird failures, │
│ coordinates sub-agents, │
│ drafts the final copy │
└────────────┬────────────────────┘
│ commands
┌──────────────┬───────┴────────┬────────────────┐
▼ ▼ ▼ ▼
Scrape Audio ASR Embeddings
(cloud) (local) (local GPU) (local CPU)
Apify yt-dlp + NeMo Parakeet Multilingual
actors ffmpeg 2× RTX 4090 MiniLM
~$12 $0 $0 · 6 min $0The frontier model runs the project. Local silicon runs the volume. That is the entire trick.
The Machine (the muscle)
My workstation is an Arch Linux box with two RTX 4090s wired to the same PSU. 24 GB of VRAM per card. They live under the desk and, yes, they heat the room in November.
My stack, in one breath: Python 3.11 in a uv-managed virtualenv, Torch 2.6 on CUDA 12.4, NeMo’s Parakeet-TDT (0.6B, RNN-T) for speech, paraphrase-multilingual-MiniLM-L12-v2 for embeddings, SQLite in WAL mode as the system of record. No inference servers. No queues. No Kubernetes. One box, one file for the database, two GPUs doing what GPUs are for.
Nothing on that list is exotic. Every piece has been shipped by someone else and given away for free. The interesting part is what I do with them once they are on the same machine.
Module 1 — Transcription
Parakeet is a small, fast, and stubbornly good ASR model. Nvidia trained it, then handed it out. It has no opinions and no API to pay.
I had two adversarial cases to keep alive at once. Long clips would blow past 24 GB if I naively padded a batch to their length. Short clips would starve the GPU sitting behind them. Two knobs fix both.
The first is windowed attention. Standard self-attention is O(N²) in the sequence length. Switch to a fixed-window variant and VRAM stops caring how long a clip is. A 27-minute podcast no longer takes the batch down with it.
The second is duration-budgeted batching. Sort clips by length, then pack up to 600 seconds of audio per batch. Long clips get their own batch. Short clips pack tight. Utilization stays high.
Result: 766× realtime. 56 hours of audio through both cards in about six minutes of wall clock.
audio files ── manifest ─┬─► shard 0 ─► GPU 0 (Parakeet) ─┐
└─► shard 1 ─► GPU 1 (Parakeet) ─┴─► merged transcriptsSix minutes. That is the whole point of owning the muscle.
Module 2 — Scrape and score
I let Apify run the scrapers. Different actors for YouTube, TikTok, and Instagram, and every one of them speaks a slightly different dialect of “please give me this profile”. Each platform has its own boobytraps. YouTube channel URLs must point at the videos tab, or the scraper politely returns nothing. TikTok wants a raw handle, not a URL. Instagram will happily hand me posts, comments, and reels if I ask correctly and nothing if I do not. This is a full afternoon of tuning that I paid once and then forgot.
I pull audio down through yt-dlp, which has quietly become a piece of critical infrastructure. YouTube now serves anti-bot JavaScript challenges. My fix is to let yt-dlp fetch a small challenge solver and run it through a local Deno runtime. Without it, every download returns 403. With it, the whole thing hums.
ffmpeg then flattens each file to 16 kHz mono WAV, which is exactly what Parakeet wants and nothing more.
Relevance scoring is my last cheap trick. Every post title, caption, hashtag, and top comments block gets embedded by MiniLM. Cosine similarity against the product’s own keyword taxonomy gives every post a score between zero and one. Comments only get pulled for posts above a threshold. That is how 3,778 posts collapse into 549 that are worth the audio download.
Notion CRM ─► SQLite ─► workers × 6 ─► items + comments
│
▼
MiniLM scoring ─► top-K per account ─► audio queueNone of this is a research problem. It is just plumbing that needs to hold at volume. SQLite in WAL mode is the boring hero. One file, six concurrent writers, no drama.
Module 3 — Orchestration
The brain I rent is Claude Opus. It never touched the volume. It ran the project alongside me.
Concretely, under my direction: it wrote the pipeline, picked the actors, corrected roughly forty percent of the seeded handles when the original CRM turned out to be full of impostors and dead accounts, debugged the anti-bot JS, debugged an OOM on a long clip, then fanned out into eight parallel research sub-agents that enriched the 68 finalists with what the web already knew about them.
That is judgment work. Small volume, high leverage, worth every cent. It is the one thing I cannot run locally at the same quality.
The Money
Now the argument that paid for my hardware. What would this run cost if I had sent the muscle work to cloud APIs at per-unit rates? Not a subscription plan. Actual tokens. Actual credits.
The rates I used, all list PAYG:
ElevenLabs Scribe. ~1 credit per 2 seconds of audio, so ~1,800 credits per hour. Business PAYG runs about $0.22 per 1,000 credits. That is roughly $0.40 per hour of audio.
Claude Opus 4.8. $15 per million input tokens, $75 per million output. Used here as the hypothetical cost of doing transcript normalization on frontier cloud, cleaning raw ASR into structured, punctuated, speaker-attributed text.
OpenAI text-embedding-3-large. $0.13 per million tokens, as the cloud comparison for MiniLM.
Local electricity. Two 4090s at roughly 450 W each, six minutes of ASR, a few more minutes of everything else, at $0.20 per kWh.
Token math for the Opus normalization pass, so you can check it:
56 h × 60 min × 150 wpm ≈ 504,000 words
× 1.3 tok/word ≈ 655,000 output tokens
input = raw transcript + prompt overhead
≈ 850,000 input tokensOne pass, side by side
Look at which rows survive both columns. The rented brain is not the expensive part. Orchestration and research are cheap because there is not much of them. The expensive part, when it is metered, is the volume inference underneath: speech and text at scale.
And at monthly cadence
Marketing does not run one pass and then leave. It runs monthly.
Cloud-only scales linearly because every hour of audio and every million tokens is metered. Hybrid scales sub-linearly because the GPUs are already there. Two 4090s cost roughly $3,200 in hardware. At 30× monthly volume, that hardware pays for itself in a single month against the cloud alternative.
The Rule
Rent the brain. Own the muscle.
I pay a flat rate for the best orchestrator I can get and let it drive. Then I run every high-volume, repetitive inference on my own machine. Speech-to-text, embeddings, bulk text normalization: these are solved problems that a $1,600 card handles in minutes.
The gap between the two paths on this job was –$84 per run and –$3,000 per month at 30× scale. That is the difference between a marketing pipeline that scales and one that gets shut down at the first budget review.
My future of AI engineering is not paying the most per token. It is knowing which tokens should never leave my building.