FreeUltraCode: An AI Coding Tool with 20+ Free LLM Channels

I've been a game developer for over a decade — Unity C#, Unreal C++, a few custom engines. Last year I started using Claude Code and Codex CLI heavily. Not for "write me a sorting function" stuff. I'm talking about having it read an entire rendering pipeline, modify logic across a dozen files, add physics debug tooling, fix multi-threaded race conditions.

Claude Code is legit. It reads the project structure first, traces the call graph, then makes changes. Runs the build, catches errors, debugs itself, iterates until it passes. Codex is sharp too — especially when GCC spits out a wall of C++ template errors, it translates the noise into human-readable diagnostics.

But the bills are brutal.

Dynamic Workflows Are Powerful. So Is the Bill.

Let me explain Claude Code's Dynamic Workflows — they're not a "paid feature." They're a built-in execution system. You write a .js script using agent(), parallel(), pipeline(), consensus(), and Claude Code orchestrates the run — sequential, parallel, voting, gating, fully automatic.

Here's a simple code review workflow:

parallel([

  agent("scan for potential bugs"),

  agent("check for security vulnerabilities"),

  agent("review performance hot spots"),

  agent("assess maintainability"),

]);

consensus([...], { strategy: "multi-lens" });

Four agents scanning in parallel, one consensus node aggregating votes. Clean.

But scale this up and it becomes a compute black hole. One parallel block with 5 agents, a pipeline with 3 stages, each stage spawning 5 more — three levels deep and you've got 75 agents running. Each agent makes independent API calls, reads files, reasons, outputs. A single complex refactor can easily spawn dozens or hundreds of agents. Thousands of API calls. One run.

Dynamic Workflows themselves don't cost extra. But it's a "more agents = more tokens" architecture — cost scales linearly with agent count. Run 100 Claude agents on a major refactor, and the token bill will blow through your monthly budget regardless.

The real tension: multi-agent orchestration is essential, but paying premium rates for an entire agent army isn't sustainable.

Free Models Are Everywhere — But Scattered

I've got API keys for these free/low-cost channels:

• 
  GitHub Models — free playground access with rate limits, needs a GitHub token (models:read scope)


• 
  Hugging Face Router — free monthly Inference Provider credits


• 
  SambaNova Cloud — Free Tier, no payment method required, daily request/token caps


• 
  Together AI — free trial credits on signup


• 
  Groq — free tier, genuinely fast inference


• 
  Gemini — Google free tier


• 
  DeepSeek / Kimi — dirt cheap


• 
  NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai — each with free or trial access


• 
  LLM7 / Kilo Gateway — keyless channels, just works


• Local: Ollama / LM Studio / llama.cpp
  

Plenty of options. But every single one requires separate registration, key management, and environment variables. Want to try Groq today? Dig through emails for the key. Want SambaNova's DeepSeek-V3.1 tomorrow? Another round of setup.

And here's the real problem: having a cheap model doesn't mean it writes good code. Free models fall short on single-pass quality compared to Claude Code or Codex — shallower reasoning, context drift on long files, sloppy on complex refactors. That's why most people hoard free keys but still pay Claude at the end of the month.

What I wanted to solve: use free/cheap models, orchestrated through workflows, to produce code quality on par with Claude Code and Codex. One cheap model can't compete. But put five of them on an assembly line — planning, executing, reviewing, cross-verifying — and the quality gap closes through structure and collaboration.

FreeUltraCode: One Dropdown, All Channels

FreeUltraCode is a local desktop app (Tauri 2 + Rust, source on GitHub). What it does is dead simple:

A dropdown menu to switch channels.

The Channel selector at the bottom lists every channel you've configured. Pick one, conversations flow through it. Setup takes three steps: select channel → click "Register" to get a key from the provider's site → paste it back. Status turns green. Done.

No proxy/VPN required, no registration handled for you, no keys stored on any server. All config, chat history, and API keys stay on your machine.

Crucially: switch channels mid-session, context is preserved. File references, intermediate conclusions, tool outputs — all carried over when you switch. No need to re-feed context.

Real-World Usage (Game Dev)

Task: "Add a climbing system to this third-person character controller"



Step 1 → Switch to GitHub Models / Groq

  Scan project structure, locate CharacterMovement, Input, Animation layers

  Read relevant code, list existing interfaces and what needs changing

  (free models handle this fine)



Step 2 → Switch to Claude Code / Codex

  Core logic — add Climbing state to the state machine,

  change physics queries from Raycast → CapsuleTrace,

  add BlendSpace to the animation blueprint

  (premium models for architectural decisions)



Step 3 → Switch to Together AI / DeepSeek

  Write tests, run lint, generate comments, draft commit messages

  (high volume, low complexity — free channels in parallel)



Step 4 → Switch back to Claude Code

  Final review — walk through all changes, check edge cases,

  confirm network sync logic isn't missing

  (quality gate needs a reliable model)

Free Auto: Let the Tool Handle Channel Switching

Manual switching works when you know which model fits the task. Sometimes you don't want to think about it. CI fails a linting task at 2 AM — you just want any free channel to fix it and stop bothering you.

That's where the Auto channel comes in (freecc:auto, first option in the dropdown). It's not a fixed upstream — it's a smart router:

1. Configure keys for however many free channels you want


2. Switch to Auto, send requests


3. The proxy cycles through channels — first one to return a valid response wins


4. Hit a 429 (rate limit)? Auto-skip, 30-second cooldown before retry


5. Hit a 5xx (upstream down)? Mark as failed, skip for this round


6. All channels exhausted? Returns 503 with a failure log showing what died and why

Connection timeouts are budgeted — no hanging on a single slow upstream. Channels that succeed are naturally prioritized (clean cooldown state); problematic ones get pushed to the back.

Net effect: fire a request, get a result, channel switching is invisible. Configure 8 channels, and Auto becomes an 8-channel failover pool — one goes down, the next picks up.

Auto can also lock a model. Set a model override like z-ai/glm-5.1 in Settings, and regardless of whether Auto routes to Groq, Together, or DeepSeek, they'll all be asked to run the same model. Useful when you know what model quality you want.

Real scenario (game dev):



2 AM. CI is red. A lint error from a Claude Code session.

You're asleep, but FreeUltraCode's scheduled task is still running.



Auto channel attempts:

  GitHub Models → 429, skip, 30s cooldown

  Groq → works, fixes it in minutes

  (DeepSeek, Together, HuggingFace never even get touched)



Wake up. CI is green. Commit is done.

You don't know whether Groq or DeepSeek fixed it.

You don't need to know.

Local Proxy: No Global Config Changes, Multiple Lines Simultaneously

Tools like cc-switch solve the same problem, but they do it by modifying Claude Code's global environment variables — switch channels, change ANTHROPIC_BASE_URL. That means you can only use one channel at a time, and it affects everything globally. Open a second terminal window, same channel applies.

FreeUltraCode takes a different path. It runs a Rust-based local reverse proxy on 127.0.0.1, routing by port path. Claude Code doesn't need any config changes — it thinks it's still talking to Anthropic's official API:

Claude Code → 127.0.0.1:8766/ch/official     → Anthropic official

Claude Code → 127.0.0.1:8766/ch/deepseek     → DeepSeek

Claude Code → 127.0.0.1:8766/ch/kimi         → Kimi

Claude Code → 127.0.0.1:8766/ch/auto         → Free Auto smart routing

Each channel maps to its own port path, no interference. You can run official Claude, DeepSeek, and Kimi Claude Code sessions all at once. The proxy handles Anthropic ↔ OpenAI protocol translation — if the upstream speaks OpenAI (Groq, Together, DeepSeek), the proxy translates; if it natively speaks Anthropic (Kimi, Z.ai), it passes through.

Even better: dynamic channel switching within a single Claude Code session. Claude Code reads ANTHROPIC_BASE_URL from the environment on every call — FreeUltraCode's gateway injects this value per-request. Which means:

Round 1:

  DeepSeek scans project structure, finds the issue → cheap



Round 2:

  Switch to Claude official → precise fix



Same session, full context preserved.

No restarting the terminal. No re-feeding file references and intermediate conclusions. DeepSeek for problem identification, Claude for the actual fix — each doing what it's best at, costs under control.

/ultracode: Cheap Models, Premium Output

This is the core of FreeUltraCode. One-line natural language task, auto-generated execution plan, parallel sub-agents — planning, execution, review, adversarial verification, acceptance gates — the entire pipeline running on your free channels.

fuc ultracode "Move weapon damage calculation from client to server, handle prediction rollback"

Six built-in strategies, auto-selected: classify-and-act, fan-out-and-synthesize, adversarial-verification, generate-and-filter, tournament, loop-until-done.

The underlying logic: replace single-model deep reasoning with structured pipelines. One cheap model struggling alone → five cheap models working in sequence, cross-reviewing, gating each other. The total cost might still be a fraction of a single Claude invocation.

Every run logs to .fuc-run/<run-id>/ with a complete audit trail: task ledger, event stream, verdict, final result.

Tech Stack

Who This Is For

• Daily Claude Code / Codex users feeling the token bill


• People with keys to multiple free channels but tired of config juggling


• Those who know which tasks can run on cheap models and which need premium, and want granular cost control


• Game/graphics/systems devs — large codebases, heavy compiles, high AI call volume

Not for casual users who ask a question once in a while. If that's you, just open a terminal and run Claude Code. You don't need a shell on top.

Default Models (Partial)

Links

• GitHub: github.com/wellingfeng/FreeUltraCode
  


• Discord: discord.gg/2C9ptSEFG
  


• QQ Group: 149523963

Get Started

cd app

npm install

npm run dev       # Web → localhost:5173

npm run desktop   # Tauri desktop app

On Windows, double-click run.bat in the repo root.