The $0 LLM Stack I Run Inside Claude Code

How I connected 30+ free AI agents to one paid Opus, made them argue with each other, and stopped burning my weekly token limit on work a free model could do.

I connected 30+ free AI agents and had no idea what to do with them

Here’s the embarrassing truth about how this started.

I had Claude Code on the Max plan, and like everyone else I was burning through my weekly token budget at an alarming rate. Every refactor, every research sweep, every “summarize these forty files” went through the expensive main agent. By Wednesday I’d be rationing. By the weekend I’d be locked out, staring at a cooldown timer, wondering why I pay for a tool I can’t use half the week.

So I did the reasonable thing: I connected thirty-something free AI agents to my setup. Web LLMs, free-tier APIs, a local model on my own GPU. And then I sat there with thirty free brains and absolutely no idea what to do with all of them.

The first instinct, route each task to whichever free model is handy, was a disaster, and I’ll come back to why. The thing that actually worked was stranger and better: I stopped asking one model for an answer and started making a panel of them argue until one survived the argument.

This is the story of that system. It runs at $0 marginal cost for everything except the orchestration, it let me build close to ten projects in about two and a half months, and it’s the reason I don’t touch Haiku or Sonnet at all, I’ve actually blocked them in my Claude Code config so the main agent can’t even spawn them. Just Opus conducting, and a free orchestra doing the work.

Stop burning your limits: delegate the heavy work

Scroll any Claude Code community and you’ll find the same complaint on repeat: “I burned my limit in three days.” And almost nobody asks the obvious question: why is the expensive agent doing the cheap work?

When I say the free fleet does the heavy work, here’s exactly what I mean, the high-volume, low-judgment grind that fills most of a session: reading files, grepping repos, summarizing logs, sweeping documentation, classifying rows, drafting boilerplate, and running the verification rounds across the clusters. None of that needs a frontier model. It needs a competent model, and there are a dozen of those for free.

So my rule is absolute: the paid main agent (Opus) only orchestrates and verifies. All the heavy lifting goes to a $0 lane. Opus decides what to do and checks it was done right; the free fleet does the doing.

The result is almost funny. Because I save so much budget on the routine work, I have absurd headroom for the rare moments that deserve frontier muscle. On day six of my weekly window, when most people are locked out, I can fire a Workflow that spawns around sixty Opus agents and burns my entire remaining weekly quota in twenty-four hours on one hard problem. Not recklessness, arithmetic. The routine work of the whole week never touched that budget, so it’s still there to spend extravagantly when it counts.

That’s the whole philosophy: be cheap on the boring 90% so you can be extravagant on the 10% that matters.

The lanes: web, API, and local

Everything routes through one interface (cc.<lane>). Under it sit three families of free compute, plus the clusters built on top of them.

Browser web lanes

These drive my own logged-in browser tabs over the Chrome DevTools Protocol. The model thinks it’s chatting with a human; it’s actually answering my orchestrator. The roster, with the exact models I run:

GLM-5.2 (Z.ai), my default reasoner, top of my leaderboard. When Z.ai’s servers are overloaded and GLM-5.2 throws a “peak hours” wall, the lane auto-falls-back to GLM-5-Turbo and resends, so a busy server degrades instead of failing.
DeepSeek V4 Pro, the heavyweight reasoner (expert + deep-think mode), no web, pure depth. Its lighter sibling DeepSeek V4 Flash is the fast non-thinking tier for quick work.
Qwen3.7 Max, hard reasoning and code.
Kimi K2.6, long-context, live-web; plus Kimi K2.7-Code through a multi-model aggregator.
Gemini 3.5 Flash, web-grounded, fast, for anything needing current facts.
Grok 4.3, the other live-web lane, quick current facts.
Mistral Medium 3.5, rounds out the live-web options.
ChatGPT 5.5, benches highest of all, but it’s anti-bot and ToS-risky, so it sits on the bench, not in the rotation.

The engineering rules that make these reliable: attach to a browser I already have open, never spawn a new tab; one CDP owner per browser (a second attach wedges the first with a broken-pipe error, so a cross-process lock guards it); capture by intercepting the site’s own response stream first, scrape the DOM only as fallback (and strip the visible “thinking” trace, I want the answer, not the monologue); and verify the send actually landed before reading back. Three browsers, three isolated debug ports, Chrome on 9222, Edge (the chat workhorse) on 9223, TradingView on 9224, one owner each.

These lanes are the flakiest part of the whole system, and I’ll be honest about that later. But they’re my only free door to the strongest reasoners that exist, and that’s worth a lot of selector-chasing.

Free-tier API lanes

Faster, more stable, no browser:

NVIDIA NIM, OpenAI-compatible access to the Nemotron family and open-weight models. After a thirty-prompt benchmark, nemotron-3-nano-30b won outright: 26/30 correct at about 183 tokens/second. It’s my default fast reasoner and the captain of two clusters. The 120B Super matches the accuracy but crawls at about 6 tok/s, useful only for its million-token context, not speed. NIM’s limits are per-minute, so it’s the lane I fan out on.
Groq, the speed demon, default gpt-oss-120b. A live check of my five active models came back clean: the two GPT-OSS models at about 0.3s, qwen3-32b and qwen3.6-27b sub-half-second, llama-3.3-70b at 1.0s. One gotcha: Groq sits behind Cloudflare, and a request without a browser User-Agent gets a 403, it’s a bot filter, not a dead lane, and the canonical client sends a proper UA and walks through. Groq’s free tier is capped by requests per day, which is unusual and worth designing around.
OpenRouter, twenty-six free models, paced to about 19 requests/minute with a cross-session lock. On paper it offers giants, a 550B Nemotron Ultra, a 405B Hermes, a million-token Qwen3-Coder, but in practice those big ones are frequently stale or unresponsive, so I treat them as a nice-to-have, not something to depend on.

The local lane

For overnight bulk and anything privacy-sensitive, a model runs on my own GPU through LM Studio. The current pick is Qwen3-4B-Instruct-2507, and it earned its seat against more than thirty free local LM Studio models, chosen not for raw accuracy but for the combination that matters on a single-GPU box: speed, low RAM footprint, and good-enough reasoning. A frugal 4B that answers fast and leaves the card free beats a heavyweight that hogs memory and stalls everything else.

It powers a nightly job: while I sleep, the local model works through memory cleanup, source scanning, idea mining, code-health checks, and a morning digest, all advisory, nothing auto-applied. Every one of those tokens would otherwise have hit the paid main agent. The box it runs on: 128 GB of RAM, an AMD Ryzen AI Max 395+ class processor, a single GPU, which is why “never load a second local model” and the strict process discipline run through the whole design.

The hero: the C1–C5 adversarial clusters

Now the part that actually made this work, and the reason I built it.

When I first had my pile of free agents, I did the naive thing: route a task to a single free model, usually one of the 120B ones, and trust the answer. It was a mess. The reasoning was weak and inconsistent. One model would confidently invent a function that didn’t exist; another would miss an edge case; a third would contradict the first two. Single-model dispatch doesn’t fail loudly, it fails plausibly, and plausible-but-wrong is the most expensive kind of wrong, because the answer looks exactly as confident when it’s wrong as when it’s right.

The fix wasn’t a better model. It was a better process. There are five clusters, each tuned for a job:

Cluster	Job	Workers	Captain
C1, Fast	read, grep, summarize	NVIDIA gpt-oss-120b · Groq gpt-oss-20b · Groq qwen3-32b	nemotron-3-nano (28/30)
C2, Code	write/fix code, compile+test	gpt-oss-120b · qwen3-32b · a Cohere code model	gpt-oss-20b
C3, General	factual analysis	gpt-oss-20b · qwen3-32b · gpt-oss-120b	nemotron-3-nano
C4, Research-web	live-web facts	Gemini · Grok · Kimi	GLM-5.2
C5, Code-web	hard code/design	DeepSeek Pro · Qwen · Kimi · ChatGPT · aggregator	GLM-5.2

The mechanic that makes them more than the sum of their parts:

Every worker answers blind and independently, no model sees another’s answer first. Independence is the point: the moment one can see another’s reasoning, they converge on the same mistake.
A closer rides every worker prompt: “What am I missing? What other elegant solutions exist?”
The captain refutes, it doesn’t average. Its job is to find the errors and reject what’s wrong, because a wrong answer three models share is still wrong, and a right answer one model found is still right. Averaging buries the lone correct voice; refutation surfaces it.
An extra re-challenge round, the captain attacks its own verified answer once more, on the theory that the most dangerous blind spot belongs to whoever has the final say.
For code, it must execute. C2 and C5 don’t trust the model’s word, they run it in a guarded sandbox. Compiles and passes the test, or it’s rejected. The interpreter has no opinions, and when you can get ground truth that cheaply, you take it.

Strip away the technology and this is the oldest idea in how humans establish truth: don’t trust a single authority, convene independent perspectives, make them challenge each other, and keep what survives. Peer review, adversarial courts, scientific replication, same insight. I just pointed it at a pile of free language models and let them referee each other.

What it fixed: errors dropped sharply, because catching wrong workers is literally the captain’s job. And the panels kept finding gems I’d never have caught alone, when I designed my browser-control layer, the C5 panel tore the first draft apart and handed back the insights that reshaped it (make the observation layer a sensor and never an executor; split the deterministic kernel from the LLM analyst; try deterministic recovery before any vision call). Several of my system-level skills were born in those sessions. The panel finds what one brain, however good, simply misses.

Opus-only: Haiku and Sonnet are blocked

A consequence that surprised even me: I don’t use Haiku or Sonnet at all, they’re blocked in my Claude Code config, so the main agent literally cannot spawn them.

Not because they’re bad, they’re excellent. But in my architecture there’s nothing for them to do. The cheap, fast work they’re for goes to the free fleet, which costs nothing instead of a little. The hard reasoning that justifies a mid-tier model goes to an adversarial panel that out-reasons any single mid-tier model. Both roles got squeezed out from both sides, so I removed the temptation entirely.

So my setup is: Opus as the one and only main agent, orchestrating and verifying, plus, rarely, a Workflow of adversarial Opus agents when a problem genuinely deserves frontier muscle on every node. Most people run a cheap model and reach up for an expensive one when stuck. I run the most expensive model as the conductor and reach down into a free orchestra for everything else. It costs less and it’s more reliable, because the orchestra checks its own work.

The traffic control nobody tells you about

With thirty-plus lanes, “which one?” can’t be answered by hand every time. A router gives me one interface over every model plus a registry, so when a lane gets deprecated or a better one appears, I change one mapping instead of a hundred call sites. A capability allocator matches a task against an index of a few hundred skills, scripts, and lanes and returns the right tool at the right difficulty, strong reasoners for code and hard problems, web-grounded lanes for current facts, the local model for bulk.

Underneath sits a per-lane scheduler that turns rate limits from a problem into a non-issue: high/low priority queues, anti-starvation, per-lane pacing tuned to each provider’s real limits, and a quota ledger that rotates away from a lane at 80% before it hits a wall. When five sessions and a nightly job all want Groq at once, the scheduler lines them up at Groq’s real rate instead of letting them stampede into a 429. The clever part of a multi-lane system isn’t the models, it’s the traffic control.

War stories: what a free fleet actually breaks

The hard part of running thirty free agents was never the AI. It was the plumbing. If you build this, you’ll hit every one of these.

The Cloudflare 403 that wasn’t a dead lane. My Groq lane started returning 403, and my first instinct, the one to resist, was to declare it dead and route around it. Wrong: the 403 was Cloudflare’s bot shield rejecting a bare request. A real browser User-Agent walks straight through. The lane was never down; my probe was. Now I treat “a lane looks dead” as a hypothesis to verify, never a fact to act on.

Two clients, one browser, instant wedge. The driver kept crashing with a broken-pipe error, only sometimes. Cause: browser-level CDP is single-client, and a second process attaching to the same browser wedges the first. The fix is a PID-keyed cross-process lock around the attach, small code that kills an entire class of impossible-to-reproduce crashes.

The flashing console windows. Background Python jobs kept opening visible console windows for a split second. The fix had two layers, launch every background job through the windowless interpreter with output redirected to a file, and flip the OS default terminal to the legacy host, and then I made it a rule the system enforces on itself: a hook that blocks any bare background python launch and demands the windowless form. The best fixes aren’t the ones you remember to apply; they’re the ones the system won’t let you skip.

The stale-orphan apocalypse. A safety limit that refuses to launch new processes when too many are already running kept blocking me when the box wasn’t busy. Two causes: finished jobs left stale orphan processes in memory (one pair sat there for thirty-nine hours), and the Windows launcher spawns the interpreter as a pair, so every job counted twice. The guard saw twenty-six processes and tripped a cap of thirty when the real number of logical jobs was three. The fix was to count what matters, exclude daemons, collapse the launcher pairs, skip the dead orphans, and add a reaper that clears stale ones on a schedule. A metric that counts the wrong thing is worse than no metric, because it earns your trust and then lies to you.

Cluster reliability. Fanning out to five web lanes plus a captain, everything goes wrong at once. A lane goes busy, so every lane has a circuit breaker and a fallchain that advances to the next available model. A capture comes back empty because the scraper finished before the model did, so it waits while the stream grows and reconciles against the final DOM if it truncated early. Two cluster batches collide on the shared scheduler and cancel each other’s work, so I run batches sequentially. None of it is glamorous; all of it is the difference between a demo and something you trust at 2 a.m.

A field guide to my lanes

After a while the lanes develop personalities. GLM-5.2 is my first call for anything that needs to think but not search. Gemini Flash and Grok are who I ask when the answer depends on something current. DeepSeek Pro is the heavyweight I save for genuinely hard logic; Qwen I trust on reasoning and code; Kimi is the long-context live-web workhorse. On the API side, Groq is for when I need an answer in three hundred milliseconds, and NVIDIA’s nemotron-nano is the quiet model that does the most work in the whole stack. And the local 4B does the most thankless, highest-volume work of all, the overnight grind and the privacy-sensitive passes, which is not what you’d expect from the smallest model in the room.

The point of having this many isn’t completeness. It’s that different work wants different shapes, fast versus deep, grounded versus pure reasoning, cloud versus local, and when each shape is one free function call away, you stop compromising.

A few honest notes before you copy any of this

Everything here is real and from my own running system. The numbers are my own benchmarks and live checks; the war-stories are bugs I actually hit; the architecture is what’s on my machine right now, not a diagram borrowed from someone else’s blog post. Where an idea came from outside, a model leaderboard I consult, a pattern I read about, I lean on it as a source, not as something to pass off as mine.

Opus is, and always has been, my one and only main agent. It never gets demoted to save tokens, because downgrading the conductor is exactly the wrong economy. You save money by delegating the work, not by dumbing down the decisions.

The web lanes were, and still are, the hardest part, and worth it anyway. Driving logged-in chat UIs is a constant fight: a site redesigns and a capture breaks; a streaming format changes overnight and an answer truncates; a session expires. Debugging is slow because half the failures only show up live, mid-stream, in a real browser. I’ve sunk more hours into the web lanes than into anything else. But they’re my only free door to the strongest reasoners on the planet, and the depth of reasoning they hand back is worth every hour of selector-chasing.

It was rough at the start, and it cost me. The early weeks were near-constant debugging, collisions, rate-limit walls, empty captures, wedged browsers, confident-but-wrong answers. Honestly, I’ve probably spent close to half my time building the rules, hooks, skills, and lanes rather than working on the projects themselves. That sounds backwards until you see the arc: the strife front-loads, every bug I fixed became a guard that stopped the next ten, and the gain is entirely long-term. Today it largely runs itself, the nightly job finishes while I sleep and the morning brief is waiting. That smoothness wasn’t designed in. It was debugged in, one strife at a time.

The skill shelf

The lanes and clusters are the engine; the skills are the controls, custom commands that turn a recurring chore into a word. The working set, grouped:

Free-LLM & clusters, /web-lane (ask any free web LLM, watch it live) · /web-chain (cross-LLM adversarial debate) · /c1–/c5 (one cluster directly) · /cluster (the full panel menu) · /free-capabilities (what the $0 lanes can do) · /browser-agent (a $0 autonomous browser worker)

Orchestration & planning, /repa (research, verify, explain, propose, ask) · /askme (interrogate me until nothing’s ambiguous) · /autonom (scope it, then work nonstop to done) · /plan-mode (structured plan before code) · /recap (session progress) · /deep-audit (five-agent research swarm)

Save, optimize, diagnose, MAX SAVE (tarball + state checkpoint) · /max-opt (deterministic-first project optimizer) · /session-insight (retrospective + fix proposals) · /cc-doctor (full live stack health check) · /health (per-subsystem verdicts) · /compact-tight (save, compact, auto-reload) · /ping45 (keep the prompt cache warm) · /qmon (cross-session background-task digest)

Data & enrichment (for a data project), /risco-enrich (company enrichment, rate-gated) · /enrichment-pipeline (the seven-step per-firm pipeline) · /cui-verifier (check a site legally shows its company ID) · /lead-promotion (gate pending leads into qualified)

Trading & TradingView, /fixp (fix Pine, push next version to cloud) · /tv-read-all (dump a strategy’s settings) · /tv-write (set inputs on a live chart) · /tv-parity (compare TradingView output to my Python) · /tv-candle-export (pull candles to CSV for offline analysis) · /megasweep (sweep a strategy across the full price history)

Content & overnight, /post (five-stage LinkedIn pipeline) · /humanizer (strip AI tells) · /qwen-nightly-cron (overnight local-LLM batch) · /QDD (the morning Qwen digest) · /skill-creator (author the next skill on this list)

Most of these started as a chore I did twice and refused to do a third time by hand.

What I’d tell you if you’re starting

The intelligence was never the bottleneck. Free models in 2026 are astonishingly capable, and the gap between a frontier model and a good free one, for the work that fills most of a session, is smaller than the price gap suggests. What separates a pile of free agents from a system you can depend on is the unglamorous engineering: the locks that stop them colliding, the pacing that respects rate limits, the reaper that clears the dead ones, and above all the refusal to trust a single answer when you can make several models argue toward a verified one.

Start absurdly small. Route one category of work, your file summaries, to one free API, and keep your expensive agent as the conductor that decides and verifies. Watch your token budget stop hemorrhaging. Then add a second model and a referee, and you’ve got a baby adversarial panel that already beats blind trust. Grow it as the chores reveal themselves.

And don’t over-trust your own judgment about what’s “dead” or “done.” Half my hardest bugs were false negatives, a lane I wrote off that was fine, a cap that lied because it counted the wrong thing. Verify against reality, not memory. Make the system check its own work, because you won’t always be there to check it for it.

I started with thirty free brains and no idea what to do with them. The answer turned out to be the oldest trick in epistemology: don’t ask one expert, convene a panel, and make them argue until the truth is the only thing left standing. The models are free. The refereeing is the craft.

The stack runs at $0 marginal cost on free tiers, browser sessions, and a local GPU. The only paid component is the Opus orchestrator, used deliberately, for the 10% that earns it.