The Free Router Switchboard

The Free Router Switchboard — Claude Code for $0.

● FREE CLAUDE CODE · OMNIROUTE + 9ROUTER · ONE SWITCH

The real Claude Code CLI — not a knockoff — pointed at two free local routers instead of a paid API. OmniRoute's keyless free pool on one rail, 9Router's token-saving fallback chain on the other, and a one-click switch between them inside the Agent OS. Everything below was built with it, for $0.

The Switchboard — a claude CLI node routing through a lit OmniRoute path with a dormant 9Router path below, and a toggle to flip between them

$0spent on every build below

593models on the OmniRoute rail

20-40%tokens saved by 9Router's RTK

1click to switch rails

The whole system in one picture: one real Claude Code CLI, two free rails, one switch.

My story · why this matters

I was paying to experiment. Then I built the switchboard.

Before.

Every idea I wanted to test cost real money.

Spin up Claude Code, build a prototype, watch the token meter run.

I'd found free gateways — but each one wanted its own environment variables, its own port, its own model names.

Get one variable wrong and the CLI silently falls back to your paid account. I burned paid tokens on builds I thought were free.

Two good free routers on my machine, and switching between them meant editing env vars in a terminal like it was 2019.

Then I wired both routers into one switchboard inside the Agent OS.

After.

Now there's one pill: OmniRoute or 9Router. Click it, done.

The CLI picks up the right rail on the next message — no env vars, no restart, no risk of silently billing my paid account.

Every experiment now runs at $0 first. The paid brain only comes out when the idea already works.

The five builds further down this page? All shipped through the switchboard — both rails. Total spend: nothing.

I · The Problem

The token meter problem.

Here's the trap.

Claude Code is the best coding agent there is — and every message costs money.

So you ration it. You save the good tool for "real" work.

Your experiments, your throwaway prototypes, your "what if" ideas — they either don't happen, or they quietly drain the same budget as client work.

Meanwhile free AI gateways exist. Good ones. But they're built for people who enjoy editing shell profiles.

Each router wants different environment variables. Ports collide. And the failure mode is brutal: point one variable wrong and the CLI logs back into your paid account without telling you.

The Free Router Switchboard fixes all of it — two free rails, wired in once, switched with a click.

THINKING IT? "Free models are too dumb to be worth routing to."

Scroll to the proof section. Three finished, polished builds — an animated orb, an interactive switchboard, a data infographic — all built by free models through this exact setup.

Free isn't for everything. It's for the 80% of work that doesn't need a frontier brain — and right now you're paying frontier prices for it.

II · How it works, in simple words

Same CLI. Different door.

Free Claude Code isn't a clone or a knockoff.

It's the actual claude CLI you already use — with one environment variable changed.

ANTHROPIC_BASE_URL tells the CLI where to send requests. Point it at a free gateway running on your own Mac, and every request routes there instead of the paid API.

The gateway speaks Claude's protocol, so the CLI never knows the difference. Tools work. Files get written. Agents run.

The switchboard part: I run two gateways side by side — because they're good at different things — and flip between them from the Agent OS.

The CLI doesn't change. The destination does.

III · The two rails

OmniRoute and 9Router — built for different jobs.

Why two routers instead of one? Because they solve different problems.

Rail one: OmniRoute — the bottomless free pool. A local gateway with a keyless free pool: 593 models listed the day I captured this, no accounts to connect, nothing to sign up for. Start it, point the CLI, build. It's the rail I leave on by default — every showcase build below went through it.

Rail two: 9Router — the token saver. An open-source router (installed with one npm command) with a trick OmniRoute doesn't have: RTK, which compresses tool results before they hit the model — 20-40% fewer tokens on agent work, where tool output is most of the bill. Plus an auto-fallback chain: your subscription → cheap → free, so a dead provider never stalls a build. It routes through accounts you connect in its dashboard, so it's the rail for squeezing paid accounts too.

The switchboard: both at once. OmniRoute owns port 20128, 9Router runs on 20129. Both stay up. The Agent OS decides which one the next claude spawn talks to — with one click.

RTK in one picture: the part of your context that balloons is the part it shrinks.

The ladder is the point: you set it up once, and "quota exceeded" stops being a work stoppage.

THINKING IT? "Is pointing my Claude CLI at some proxy safe?"

Both routers run on your own machine — 127.0.0.1 means requests never leave your Mac except to the model provider you chose. No third-party middleman server.

9Router is open source (read every line on GitHub), and OmniRoute runs entirely locally too. The one real risk is misconfiguration silently using your paid account — which is exactly what the switchboard's status chips make visible.

V · The Switch

One pill in the Agent OS. That's the whole UX.

Here's what wiring this into the Agent OS actually looks like.

The Free Claude Code panel has a ROUTER switch — two pills, OmniRoute and 9Router, each with a live health dot.

The Free Claude Code panel in the Agent OS on the OmniRoute rail — header chip reads BIG-PICKLE · OMNIROUTE · FREE POOL, with the ROUTER pill switch visible

What you're looking at: my Agent OS on the OmniRoute rail. The header chip reads BIG-PICKLE · OMNIROUTE · FREE POOL — the CLI is live on the keyless free pool. Note the ROUTER pills under the description: both dots green, both gateways up.

Click the other pill and everything flips — the chip, the model, the gateway the next message routes through:

The same panel flipped to the 9Router rail — the header chip flips to the 9ROUTER · RTK TOKEN SAVER rail

Same panel, one click later — the chip flips to the 9ROUTER · RTK TOKEN SAVER rail. One honest detail from my own setup: before I connected a provider, this panel showed an amber warning card instead of routing — 9Router routes through accounts you connect, and the OS tells you that plainly instead of failing mysteriously. Two connected providers later, the same rail answers a real claude -p request end-to-end.

Under the hood it's one JSON field. The choice persists to ~/.agentic-os/fcc.json, and the next claude spawn reads it and gets the matching environment. No restart. No terminal.

One click → one JSON field → the right environment on the very next message.

VI · The proof

Built through the switchboard. Total cost: $0.

Talk is cheap — so here's what Free Claude Code actually shipped through both rails, each one from a single prompt. Aurora Storm came down the 9Router rail on gemini-3.6-flash; the rest rode OmniRoute's free pool.

This one's live — click the toggle inside it:

A live, interactive piece — built by a free model, through the free rail, from one prompt. Flip its switch and watch the lit path swap. This is the exact system this guide describes, drawn by the system itself.

And the rest of the $0 shelf — click to play them full-screen:

Aurora Storm — flowing teal and violet aurora ribbons over a starfield, built via the 9Router rail

Aurora Stormvia 9Router · mouse-bent aurora + shooting stars

Neon City — synthwave skyline with a pink sun and scrolling grid floor, built via OmniRoute

Neon Cityvia OmniRoute · synthwave skyline, parallax on mouse

Router Orb — 90 provider nodes orbiting a glowing core

Router Orb90 provider nodes orbiting a live core

RTK Token Saver — animated infographic of tool output being compressed

RTK Token Saverhow tool output gets compressed, animated

The Switchboardone CLI, two routers, click to flip

THINKING IT? "Fine for toys — but free models can't do real agent work."

These aren't chat replies — the CLI planned each build, wrote the file to disk, and finished the job through tool calls, on a free model. That is agent work.

The honest split: frontier models are still better at big, complex builds. Which is exactly why it's a switchboard and not a religion — free rails for volume and drafts, your paid brain for the hard 20%.

VII · Old way vs new way

What changes in your day.

OLD WAY the token meter runs on everything

Every experiment bills the same account as client work
Ration the good tool — most ideas never get tried
Free gateways = hand-editing env vars per terminal
One wrong variable silently bills your paid account
Provider hits a limit → your build stalls, you wait
Tool output balloons your context and your bill

NEW WAY with the Free Router Switchboard

Experiments run at $0 on the free rails first
Same real Claude Code CLI — tools, files, agents
Two rails wired once, switched with one click
Header chip always shows which rail is live
9Router's ladder slides past dead providers
RTK trims 20-40% of tokens on agent work

VIII · The framework

The Free Router Switchboard.

Five parts, wired once.

The Free Core

The real claude CLI with its base URL pointed at localhost. Nothing forked, nothing downgraded — the same agent, through a free door.

ii.

Rail One: OmniRoute

The keyless free pool — 593 models, zero accounts, zero setup beyond starting it. The default rail for everyday building.

iii.

Rail Two: 9Router

The token saver — RTK compression (20-40% off agent work) plus the subscription → cheap → free fallback ladder and multi-account rotation.

iv.

The Switch

One pill in the Agent OS. Persists to a config file, applies on the next spawn, and the header chip always names the live rail.

The Proof Shelf

Real builds shipped through the free rails, kept where you can play them — so "free is good enough for this job" is a fact you can check, not a guess.

Any one piece is nice. Wired together, they change the default: every idea gets tried, because trying is free.

IX · Three beliefs to drop

What's actually holding you back.

Wrong: "Free Claude Code must be a sketchy clone of the real thing."

Right: It's the genuine CLI with one environment variable changed. Anthropic built the base-URL override in; routers just give it somewhere free to point.

Wrong: "One good router is enough — a second is overkill."

Right: They're different tools. OmniRoute is a bottomless free pool; 9Router saves tokens and ladders across your paid accounts. The switch costs one click, so you keep both strengths.

Wrong: "Saving tokens is pinching pennies — just pay for the good model."

Right: Agent loops multiply every wasted token by hundreds of steps. RTK's 20-40% isn't pennies — it's the difference between an agent you leave running and one you babysit.

Don't take my word for it

Members post their wins every day — agency owners, ecom founders, course creators, solo operators across 38 countries. Real businesses, real numbers, in their own words.

Read the 158-page wins doc →

X · Build it yourself

Wire your own switchboard — step by step.

Everything here is free. Budget 20 minutes.

Install the CLI. If you don't have Claude Code yet: npm install -g @anthropic-ai/claude-code. This is the only piece that's also your paid tool — the routers never touch that account unless you point them at it.

Start rail two: 9Router. npm install -g 9router then 9router -p 20129 -H 127.0.0.1. Port 20129 keeps it clear of OmniRoute's 20128. Open http://127.0.0.1:20129, log into the local dashboard, and connect at least one provider — an API key on a free tier is fine, and OAuth logins for tools you already pay for work too. No providers connected = it lists models but can't route. Mine runs two: a Gemini key and an OpenRouter key — and the receipt is real: claude -p through this rail answered end-to-end.

Start rail one: OmniRoute. In the Agent OS it's the OmniRoute tab — one click and the free pool is live on port 20128. Its pool is keyless: no accounts, no dashboard step.

Point the CLI at a rail. The three variables that matter:
ANTHROPIC_BASE_URL=http://127.0.0.1:20128 (the rail), ANTHROPIC_AUTH_TOKEN=free-local, and ANTHROPIC_API_KEY=free-local. That last one matters most — without it, the CLI's saved login quietly wins and you're back on the paid account.

Test it. claude -p "say OK" with those variables set. Answer comes back → your CLI just ran for $0. Swap the port to 20129 and the same command rides the 9Router rail.

Add the switch. Inside the Agent OS this is done for you — the ROUTER pills write ~/.agentic-os/fcc.json and every spawn reads it. Rolling your own? Persist one field, {"router": "omniroute" | "9router"}, and pick the env block off it at spawn time.

THINKING IT? "Free models think forever and never act — I've seen it."

Real problem, solved with one line. Free reasoning models love to deliberate, so the Agent OS prepends a steer to every free-rail prompt: act immediately, minimal reasoning, use your tools and stop.

That one sentence is the difference between a free model that rambles and one that ships files. Steal it.

XII · What you walk away with

The recap.

You stopped metering ideas.

The real Claude Code CLI, running $0 through local free rails.

You got a bottomless pool.

OmniRoute: 593 models, keyless, one click in the Agent OS.

You got a token saver.

9Router's RTK trims 20-40% off agent work, plus the fallback ladder.

You got the switch.

One pill flips rails, persists, and names the live rail in the chip.

You got honest status.

No providers? Rail down? The panel says so — no silent paid billing.

You got receipts.

Five live builds on this page, shipped through both free rails.

4,000+ founders inside AIPB
400K YouTube subscribers
38 countries · live members
163K X followers