The Proxy That Lets Claude Code Run on Free GPUs and Local LLMs

The Hype Moment

Claude Code has become the default reference point for agentic terminal coding. A recent survey of CLI tools placed it at the top of the stack for daily professional use, citing its low error rate and proficiency at invoking tools and terminal commands [12]. Enterprise signals reinforce that status: Microsoft made Claude Sonnet 4 the default model for GitHub Copilot CLI, an endorsement from a competitor’s ecosystem that validates the model quality behind the interface [10]. Yet the same survey noted that developers were already modifying Claude Code to route through third-party providers, including local instances, to sidestep Anthropic API costs [12].

The demand for a free ride is loud and measurable. Reddit threads ask whether Claude Code is free [3], and a YouTube guide on using it without a subscription has drawn over four hundred and fifty thousand views [6]. Security analysts have separately documented a broader CLI comeback for AI assistants, as developers seek terminal-native workflows that avoid the bloat of full IDEs [7]. This repository is the technical answer to that demand. It is not a clone of Claude Code; it is a parasitic proxy that keeps the client’s interface intact while replacing the billing backend.

Anatomy of a Protocol Hijack

At its core, the project is a protocol adapter. Claude Code expects an Anthropic Messages API endpoint. The proxy, built on FastAPI, exposes the expected routes—messages, model lists, and token counting—then rewrites and forwards traffic to one of seventeen upstream providers. Those backends are a mixed bag of protocols. NVIDIA NIM, OpenRouter, Google AI Studio, Groq, and Cerebras speak OpenAI-style chat completions. DeepSeek, Kimi, Fireworks AI, Z.ai, and Wafer speak Anthropic-style Messages. LM Studio, Ollama, and llama.cpp run locally and need their own dialects handled. The proxy normalizes streaming server-sent events, thinking blocks, tool-use metadata, and token counts into the exact shape Claude Code expects.

The provider registry separates OpenAI-compatible transports from Anthropic-compatible ones, letting contributors add a new backend by implementing the correct adapter interface and registering it in the catalog. Two features stand out as particularly gritty engineering. First, a heuristic tool parser: when a free or local model emits a tool call as raw text rather than structured JSON, the proxy auto-parses it into native tool-use blocks so Claude Code’s agent loop does not break. Second, subagent control: the proxy intercepts task-tool requests and forces background execution off, preventing a cheap local model from spawning runaway processes. There are also local request optimizations that answer trivial Claude Code probes without burning upstream quota. The launcher script additionally raises the auto-compaction window to one hundred ninety thousand tokens, a product-level tweak that reduces context-loss friction during long sessions.

The Provider Bazaar

The repository’s real inventory is its provider list. It supports NVIDIA NIM, OpenRouter, Google AI Studio, DeepSeek, Mistral’s La Plateforme and Codestral, OpenCode Zen and Go, Wafer, Kimi, Cerebras, Groq, Fireworks AI, Z.ai, LM Studio, llama.cpp, and Ollama. Many of these backends offer free tiers or trial quotas. In a market where AI coding startups are negotiating multi-billion-dollar valuations and enterprise teams spend seven figures annually on tokens, the ability to route lightweight requests to a free Google AI Studio flash model or a local Ollama instance represents a meaningful budget hedge [10].

The proxy allows per-tier routing, so the Opus, Sonnet, and Haiku designations can each point to a different provider. This means a developer can send heavy reasoning tasks to a free cloud model, fast autocomplete to a local GGUF, and fallback traffic to an experimental endpoint, all without changing Claude Code’s own model picker logic. The proxy’s models endpoint even feeds the native picker when gateway discovery is enabled.

From Terminal to Chat Bot

The project is not limited to the terminal. It documents integration paths for the VS Code extension and JetBrains ACP, routing those clients through the same proxy. It also wraps the entire stack in optional Discord and Telegram bots, complete with session branching, progress streaming, and remote task control. A voice-note layer—using local Whisper or NVIDIA NIM transcription—lets users dictate coding tasks into a chat thread. Configuration happens through a loopback-only Admin UI, a sensible security default that keeps API keys off public interfaces.

Glue Code, But Well-Engineered

It is fair to call this what it is: sophisticated glue code. The repository does not train models, invent new architectures, or redefine the coding paradigm. Its value lies in integration breadth and edge-case hygiene. It implements rolling-window rate limiting, reactive exponential backoff on rate-limit errors, and concurrency caps across all providers. It strips known-unsupported request fields for Groq and warns when llama.cpp context sizes are too small. The codebase is modern Python, managed with uv, linted with Ruff, and type-checked with Ty. A full check sequence—formatting, linting, type checking, and unit tests—is enforced in continuous integration, which is more discipline than many infrastructure scripts demonstrate. The maintainers explicitly reject Docker integration pull requests, suggesting a preference for lightweight, direct deployment.

That said, the project carries the fragility inherent to any middleman. If Anthropic changes Claude Code’s client-side protocol, the proxy must scramble to catch up. And while the Admin UI is restricted to localhost, users are still funneling API keys through a third-party proxy, a trust decision that each developer must weigh.

What It Means for the AI Landscape

This proxy sits at the intersection of two powerful trends: the agentic pivot toward autonomous CLI coding, and growing developer resistance to vendor lock-in. Industry analysis shows that while AI coding assistant adoption is nearly universal, trust in model accuracy has cratered to twenty-nine percent [10]. In that environment, the ability to arbitrage backends—to swap a paid model for a local alternative mid-session—is not a gimmick; it is a survival tactic.

By decoupling Claude Code’s polished frontend from Anthropic’s billing backend, the proxy turns a proprietary client into a generic agent shell. It is a different strategy than true open-source alternatives such as OpenCode, which rebuild the entire stack [12]. Instead, this project parasitizes Anthropic’s client investment, preserving the UX while letting the user shop for brains elsewhere. Whether that approach endures depends on how long Anthropic tolerates the protocol stability, and how quickly the open-source backends can match the reasoning quality of Claude Sonnet 4. For now, it is one of the most pragmatic bridges between a premium interface and a free-model economy.