Every contributor already has a free turbo mode: 149 subagent-sized calls in 1.4 s across 6 providers

[kvnloo]

Note

Drafted by Claude Opus 5.5 in Hermes (via T3 Code) from our own runs; posted at @kvnloo's request. All numbers are from Nov 2 2026; raw logs and the script are available on request.

TL;DR

Most people who contribute here have free API access they never use: Groq, OpenRouter :free, NVIDIA NIM, Google AI Studio, Vercel AI Gateway, and usually a Cerebras trial. Each lane alone is limited. Put them all in parallel, give each model the work its speed suits, and you get this:

• 149 small tasks in 1.44 s (5,387 tok/s). One at a time, the same calls take 54.6 s.
• 40 ~250-word answers in 2.26 s (36,141 tokens, about 16,000 tok/s).
• About 49,000 tokens in the first 3.6 s across 194 calls, while verifiers, races and two long background jobs ran alongside.

Speed is no longer the problem. Orchestration is. T3 already has most of what it needs to use this.

Get every key in one command: most providers offer GitHub or Google sign-in. onboard.py (standard library only) opens every key page, takes each pasted key without echoing it, checks it with a free /models call, and saves it (mode 600). --export opencode prints provider entries for an OpenCode instance in T3.

curl -fsSLO https://raw.githubusercontent.com/kvnloo/z0evals/179fb94/studies/free-stack-v0/scripts/onboard.py
python3 onboard.py --open-all && python3 onboard.py --check

1. The free stack

17 free model routes answered, each called directly with streaming. TTFT is the time from sending the request to the first token. Tok/s is output speed on a ~400-word answer (first to last token).

Provider	Model	TTFT	tok/s	Billing
Cerebras	qwen-3.8-27b	0.17 s	2,015	trial credit
Cerebras	gpt-oss-120b	0.21 s	1,669	trial credit
Groq	gpt-oss-20b	0.34 s	895	free
Groq	qwen3.8-27b	0.20 s	502	free
Groq	gpt-oss-120b	0.20 s	486	free
Vercel AI Gateway	nemotron-3.5-lightning-free	0.51 s	313	free credit
Google AI Studio	gemini-3.5-flash-lite	0.57 s	310	free (may train)
OpenRouter	nemotron-3.5-super-vl:free	0.47 s	147	free
NVIDIA NIM	nemotron-3.5-lightning-30b-a3b	0.30 s	117	free (dev program)
NVIDIA NIM	nemotron-3.5-super-vl-120b-a12b	0.42 s	115	free (dev program)
Vercel AI Gateway	ling-3.1-flash-1019	0.99 s	108	free credit
OpenRouter	dots-3-note-preview:free	0.62 s	98	free
OpenRouter	nemotron-3.5-lightning:free	0.38 s	96	free
OpenRouter	north-mini-code:free	0.28 s	77	free
OpenRouter	nemotron-3-ultra-550b-a55b:free	0.51 s	59	free
NVIDIA NIM	nemotron-3-ultra-550b-a55b	0.72 s	34	free (dev program)
OpenRouter	xing4.0-29b-a4b:free	0.29 s	32	free

Every model's TTFT is under 1 s. What separates them is output speed, from 2,000 tok/s down to 32. That decides what each one is good for.

Didn't answer tonight: OpenCode Zen free (FreeUsageLimitError), OpenRouter gemma-4 (429), inkling-small (403, harness-only), Vercel beam-free (403, paid only), NIM step-5-preview (timeout). We also couldn't test Nous Portal's free models (50 RPM / 500K TPM) or OpenCode Go because of expired logins on our side. Free routes come and go, so a router has to probe them.

2. Match the job to the lane

Role	Lanes	What they do	Why
Sprinters	TTFT < 0.6 s, ≥ 300 tok/s (Cerebras, Groq, Vercel lightning, Gemini Flash Lite)	fan-out of many small tasks, drafts, bulk text	Fast first token and fast output. Spread load by each model's rate limit, because Groq free is 30 RPM / 8K TPM per model.
Checkers	TTFT < 1 s, 60–300 tok/s (OpenRouter and NIM Nemotron, dots, north-mini, ling)	PASS/FAIL verdicts on drafts; racing two lanes on the same question	Short answers make TTFT the cost, not tok/s. Lanes from other providers give independent checks.
Racing	two checkers from different providers on the same question	keep the first good answer	Free lanes are noisy: one NIM model took anywhere from 2.8 s to 12.6 s across five races.
Long thinkers	< 60 tok/s (Nemotron Ultra 550B)	background jobs nobody is waiting on	The quality is free. Just don't wait on it.

3. Everything at once

All of these started in one burst, using 15 lanes across 6 providers:

Pattern	Calls (ok)	Wall time	Output
Fan-out: 150 one-word classifications	149 / 150	1.44 s (p50 0.25 s per call)	5,387 tok/s; 54.6 s if run one at a time
Bulk: 40 ~250-word explanations	38 / 40	2.26 s	36,141 tokens, about 16,000 tok/s
Draft → check: sprinter drafts, a checker from another provider gives the verdict	7 drafts, 6 checks	drafts 0.3–2.5 s, checks 6–32 s	2 drafts failed on substance (e.g. open-addressing probe length), 2 passed, 1 check caught a draft that came back empty; 1 checker used its whole token budget reasoning
Racing: same question to two lanes	12 / 12	first good answer: median ~0.7 s	waiting for both: median ~5 s, worst 12.6 s
Long background: Nemotron Ultra 550B	2 / 3	81 s and 150 s	a full long-form answer while everything else finished

To be clear: about 97% of the bulk tokens came from Cerebras, which is trial credit, not a free tier. Groq is truly free but limited to 8K tokens per minute per model. The design has to treat each lane's limits as the key input.

4. Turbo mode for open source, built on a router

We run all of this behind one OpenAI-compatible endpoint: vLLM Semantic Router in k3s, with fallback on 413/429/5xx and one "virtual model" per goal (turbo, free-verify, free-longctx…). Earlier runs through it: 60 calls went from 13–18 s one at a time to 1.2 s; 200 calls with 50 in flight all succeeded, with 39 rescued after Groq 429s.

Our downstream work, all public: the router deploy, profiles and benches in z0intelligence#289 (roadmap #296); the turbo runtime and matched A/B in z0intelligence#176; lane placement in kerdoios#69; upstream fixes via our semantic-router fork. The full study, data and scripts: z0evals free-stack-v0 (write-up).

About training data: some free tiers may train on prompts. For most work in a public open-source repo that doesn't matter, because the code, issues and diffs are already public. A turbo mode aimed at OSS work can use every free lane without a privacy trade-off, as long as it keeps secrets out (.env, tokens, private repos stay on paid routes). That opens free capacity to every contributor.

5. Others are already doing pieces of this

• claude-code-router routes Claude Code's background and subagent calls by scenario (background → groq,…), with per-subagent model tags and fallback chains.
• claude-code-multirouter keeps Opus for the main session and sends subagents to Cerebras or a Codex subscription.
• vLLM Semantic Router puts fallback, confidence escalation and bounded fan-out behind one model name (micro-agent post).
• Cognition runs its parallel code-search subagent (SWE-grep, "Fast Context") on Cerebras (case study). Cerebras's own guidance is to revisit any design that exists only because LLM calls were slow.

6. What T3 has, and what it's missing

Works today: add an OpenCode provider instance with Groq/Cerebras keys and delegate_task to it. A delegated task on Cerebras gpt-oss-120b finished end to end in 4.0 s.

Where it stops:

1. Agent-sized prompts don't fit free tiers. The same delegation to Groq free failed with TPM: Limit 8000, Requested 16772: the child agent's own prompt is twice the budget. Free lanes suit small calls without tools, but every T3 delegation starts a full agent session.
2. Nothing fans out. In a matched A/B, a coordinator with fast helpers saved only 4–5% of wall time, because the helpers never ran concurrently.
3. The coordinator can't see limits. Spreading load by remaining capacity is what stops 429 cascades.

Related threads: #15182 (routing rules for subagent delegation), #16187 (usage in orchestrator_capabilities), #9801 (fall back across providers), #7366 (OpenAI-compatible driver), #28796 (compare models).

7. Why it matters: fixing things live while you dogfood

This pairs with #26971 (spoken instructions + preview annotations → one reviewed message) and #22091 (voice calls with a thread). You circle the broken thing in the preview and say what's wrong. Sprinters write the triage and repro steps in about a second, checkers verify them, the main model writes the fix, and the preview reloads while you're still looking. We dogfood this loop daily. Most of the waiting in it was orchestration, not the main model.

Direction question

Which of these, if any, fits T3? Smallest first:

1. Docs only: a "free turbo lanes" recipe (provider instances plus orchestration instructions for sprinters, checkers, racing and verification). We can write it from these runs.
2. Limits in orchestrator_capabilities (Show provider usage limits in orchestrator_capabilities so agents can avoid rate-limited providers #16187), so coordinators can spread work across per-model buckets.
3. A lightweight one-shot delegation without tools or a harness prompt, so a task fits free-tier budgets. If that's out of scope for core, we'll prototype it as an ACP agent and report back.

Caveats

• Cerebras is trial credit. Groq, OpenRouter :free, NIM (dev program), Gemini and Vercel's monthly credit are the free part.
• Single runs, Nov 2 2026. Free capacity is shared and changes by the hour.
• Token counts include reasoning tokens for reasoning models.
• Free lanes got only easy tasks that can be checked: classification, explanations, verdicts. No code edits.