DEV Community: CodeKing

"My Company Has Azure OpenAI. My AI Coding Tools Had No Idea What to Do With It."

CodeKing — Wed, 15 Apr 2026 03:03:11 +0000

My company's Azure OpenAI deployment has been running for eight months. Enterprise-grade security controls, compliance logging, the whole setup. Every team that needs AI API access routes through it.

Every team except the ones using AI coding tools.

Claude Code talks Anthropic protocol. Codex CLI talks OpenAI protocol, but to the public endpoint. Azure OpenAI is a different enough target that just pointing the tools at it doesn't work — and the error messages are not helpful when it silently fails.

What Makes Azure OpenAI Different

If you've only used the direct OpenAI or Anthropic APIs, Azure OpenAI looks similar at first glance. It's still a REST API, still returns completions. But the differences compound quickly when you're trying to make a proxy work:

Endpoint format is different. Instead of api.openai.com, you have a resource-specific URL:

https://your-resource-name.openai.azure.com

Models are replaced by deployments. You don't call gpt-4o. You call a deployment — an instance you created in the Azure portal that points to a model. The deployment name is arbitrary (my-gpt4-deployment, prod-coding-model). Your code has to know it.

API version is required. Every request needs a ?api-version=2024-10-21 query parameter (or similar). Miss it and the request fails with a cryptic error.

JSON Schema rules are stricter. Azure OpenAI's tool definition validation rejects things the direct OpenAI API accepts — $schema, $id, definitions fields, const values. If your tool definitions contain any of these (and Claude Code's do), requests fail silently.

That last one took me an embarrassingly long time to figure out.

The Translation Problem

Claude Code sends requests in Anthropic's Messages API format. Azure OpenAI accepts OpenAI's Responses API format. Between those two surfaces there's:

A message format translation (Anthropic content blocks → OpenAI messages)
Tool definition translation (Anthropic tool schema → Azure-safe OpenAI tool schema)
Response translation back (OpenAI completion → Anthropic-format streaming response)
Schema sanitization that strips the fields Azure rejects and converts const to enum

The sanitization step is the one that actually makes things work. Claude Code includes hosted tool definitions with JSON Schema features that Azure's stricter validator rejects. The proxy strips $schema, $id, $defs, $comment, definitions, and examples fields, and converts const: value to enum: [value] before forwarding. Azure accepts the result.

Setting It Up in CliGate

CliGate now supports Azure OpenAI as a native key type. In the API Keys tab, add a new key and select Azure OpenAI as the provider. You'll fill in four fields:

API Key — your Azure OpenAI resource key from the Azure portal
Base URL — https://your-resource-name.openai.azure.com
Deployment Name — the name you gave your deployment in Azure (e.g. gpt4o-prod)
API Version — e.g. 2024-10-21

Once saved, that key appears in your routing options. You can assign it as the backend for Claude Code, Codex CLI, or the chat UI — or let the router pick it based on priority settings.

From Claude Code's perspective, nothing changes. You're still hitting localhost:8081 with Anthropic credentials. The proxy handles the translation, the schema cleaning, the deployment name injection, and the API version parameter. The response comes back in valid Anthropic streaming format.

Why This Matters for Enterprise Teams

The practical upshot: your AI coding tools now route through your company's Azure deployment.

That means:

Requests flow through your company's network controls and compliance logging
You're not using personal API keys or personal accounts for work
Usage appears in your Azure portal dashboards alongside other company AI usage
The content controls and safety policies your company configured in Azure apply

For teams where "just use the public API with your personal key" isn't an acceptable answer — because it usually isn't on enterprise projects — this closes a gap that's been annoying for a while.

One Thing to Watch

Azure OpenAI deployments have their own rate limits, set at the deployment level in the Azure portal. If you're routing multiple AI coding tools through a single deployment, you can hit those limits quickly during intensive sessions. The proxy handles failover to other keys if you've configured them, but it's worth sizing your deployment quota for the team's expected usage before you roll this out.

The Azure OpenAI provider in CliGate is part of the open-source release: github.com/codeking-ai/cligate

If you're in an enterprise setup and have gotten AI coding tools working through your company's infrastructure — curious how you handled it. Azure, on-prem, something else?

"How I Route claude-sonnet-4-6 to GPT-5 Codex — Without Claude Code Knowing the Difference"

CodeKing — Tue, 14 Apr 2026 02:37:28 +0000

Claude Code always sends claude-sonnet-4-6 in the request body. That string goes to whatever base URL you've configured.

Here's what most people don't realize: that string doesn't have to end up at Anthropic.

It doesn't even have to end up at a Claude model.

The Model Name Is a Routing Hint, Not a Destination

When Claude Code makes a request, it sends something like this:

{
  "model": "claude-sonnet-4-6",
  "messages": [...],
  "stream": true
}

If your ANTHROPIC_BASE_URL points to a local proxy instead of api.anthropic.com, that proxy receives the request first. It can read the model field, and decide what to do with it.

That decision is entirely up to you.

What CliGate Does With It

CliGate is a local proxy that sits at localhost:8081. Every AI coding tool I use — Claude Code, Codex CLI, Gemini CLI — routes through it.

When a request for claude-sonnet-4-6 arrives, CliGate checks its routing table:

claude-sonnet-4-6  →  ChatGPT account pool  →  GPT-5.2 Codex
claude-opus-4-6    →  ChatGPT account pool  →  GPT-5.3 Codex
claude-haiku-4-5   →  Kilo AI (free)        →  DeepSeek R1 / Qwen3

Claude Code asked for claude-sonnet-4-6. What actually handles the request is GPT-5.2 Codex, via a rotating pool of ChatGPT accounts. The response comes back in Anthropic's response format. Claude Code never knows the difference.

Why This Works

The magic is in protocol translation. CliGate translates between Anthropic's Messages API format and OpenAI's Chat Completions format at the proxy layer. Claude Code speaks Anthropic protocol. GPT-5.2 Codex speaks OpenAI protocol. The proxy bridges them invisibly.

From Claude Code's perspective, it sent a request and got back a valid streaming Anthropic response. The model name in the response is echoed back correctly. Everything behaves as expected.

The same logic applies to the haiku model. When Claude Code sends a quick completion request using claude-haiku-4-5, that gets routed to DeepSeek R1 or Qwen3 through Kilo AI — completely free, no API key required. Claude Code sees a streaming Anthropic response and moves on.

Setting This Up

The routing table lives in CliGate's Settings tab. Each model can be mapped to:

A specific ChatGPT account (or the account pool, for automatic rotation)
A Claude account (direct Anthropic protocol, no translation needed)
An API key (OpenAI, Anthropic, Azure, Vertex AI, Gemini, etc.)
The free routing path via Kilo AI

You can also set a Priority Mode for each model: account pool first (free tier), or API key first (more reliable). If the first option fails or is exhausted, the proxy falls back to the next one automatically.

One practical configuration I've settled on:

claude-sonnet-4-6:  ChatGPT account pool  (4 accounts, round-robin)
claude-opus-4-6:    Anthropic API key     (reserved for long context work)
claude-haiku-4-5:   Free routing          (DeepSeek R1 via Kilo AI)

This means the vast majority of my coding requests go through the ChatGPT account pool at no API cost. The Anthropic key only gets touched for heavy reasoning tasks. Haiku requests are free.

The Part That Surprised Me

I expected some quality degradation when routing sonnet requests to GPT-5.2 Codex. For most coding tasks, I didn't notice any.

Code generation, test writing, refactoring, explaining stack traces — these all behaved identically from Claude Code's interface. The model was different. The output quality was comparable. The cost was zero (account pool, no API billing).

The cases where I do notice a difference are long multi-file reasoning tasks, where I've configured the fallback to use the Anthropic API key directly. But those are a small fraction of the total request volume, as the usage stats from yesterday confirmed.

Why This Matters Beyond Cost

The cost savings are real, but that's not the most interesting part.

The more interesting implication is that your AI coding tool no longer locks you into a single provider's ecosystem. You chose Claude Code for its UX and agent loop — not necessarily because Anthropic's API is the only place you want your requests going.

With a proxy routing layer, those are two separate decisions. You can use the tool you like with the backend that makes sense for each request type.

The model name in your config is just a string. Where it goes is up to the routing layer.

CliGate is open source: github.com/codeking-ai/cligate

Curious what routing setups others have tried — are you using a single provider for everything, or have you experimented with mixing backends?

"My AI Coding Tools Were Running Up a Tab I Couldn't See — So I Fixed That"

CodeKing — Mon, 13 Apr 2026 03:16:31 +0000

Three months ago I had four AI coding tools set up: Claude Code, Codex CLI, Gemini CLI, and a chat UI for quick questions. Every month I'd get a bill from Anthropic and a bill from OpenAI and vaguely wonder what I'd actually spent them on.

I had no idea which model was being called when. I didn't know if Claude Code was routing to Sonnet or Opus. I didn't know how many tokens Gemini was burning in the background. I just paid the bill and moved on.

Then I looked at one month's invoice line by line.

The answer was uncomfortable.

The Problem With Opaque AI Billing

When you use AI coding tools directly, the billing is aggregated. You see "claude-sonnet-4-6: 2.4M tokens" but you don't know:

Which tasks generated those tokens (code review? refactors? quick completions?)
Which tool was responsible (Claude Code? your chat UI?)
Whether any of it could have been handled by a cheaper — or free — model

You're essentially flying blind. You optimize what you can measure, and the billing dashboards the providers give you aren't built for developers trying to understand usage at the tool level.

What I Did About It

CliGate is a local proxy I built that sits between your AI coding tools and the upstream APIs. All four tools route through it — one localhost:8081, one place to manage credentials and routing.

That position in the stack turned out to be the perfect place to add cost tracking.

Every request passes through the proxy. The proxy knows: which tool sent it, which model was requested, how many tokens were used (from the response stream), and what each model costs per token. The math is simple. The data is suddenly very visible.

Here's what the usage dashboard looks like after a week of normal coding work:

Provider breakdown (this week)
──────────────────────────────────────────
Anthropic API          $4.82   68%
ChatGPT Account         $0.00    0%   ← account pool, no API cost
Free (Kilo AI)          $0.00    0%   ← routed to DeepSeek/Qwen
OpenAI API              $2.27   32%
──────────────────────────────────────────
Total                   $7.09

Model breakdown told an even more interesting story:

claude-sonnet-4-6       $4.21   59%
claude-haiku-4-5        $0.00    0%   ← free routing active
gpt-4o                  $1.89   27%
codex-mini              $0.38    5%

The haiku line at zero was the thing that made me stop and think.

The Bit I Didn't Expect: Some Models Are Just Free

CliGate has a feature called free model routing. When a request comes in for claude-haiku-4-5, instead of forwarding it to Anthropic, the proxy routes it to a free model — DeepSeek R1, Qwen3, MiniMax, whatever you've configured — via Kilo AI. No API key needed.

I turned this on almost as an experiment. But looking at the usage stats a week later: every quick question, every short completion, every "what does this function do" — all of that had been handled for free. The expensive Sonnet calls were left for the work that actually needed it.

That split happened automatically. I didn't have to think about it.

You can change which free model handles haiku requests from the Settings tab. I've been rotating between DeepSeek R1 and Qwen3 depending on the task type — DeepSeek for reasoning-heavy work, Qwen3 for code generation.

The Details That Actually Changed My Behavior

Per-account tracking. I have multiple Claude accounts in the pool. The usage stats break down by account, so I can see if one account is hitting its quota faster than others and rebalance.

Daily and monthly views. You can toggle between a daily sparkline and a monthly total. The daily view is where you catch the outliers — that one afternoon you had three long Claude Code sessions refactoring a module shows up as a spike and explains why a particular week cost more.

Pricing registry. Every model's per-token price is configurable. When OpenAI changes pricing (which happens), you can update it in the dashboard without touching any config files. You can also add manual overrides for models that aren't in the default list.

Cost per request in the logs. The request log view shows cost alongside each request. If something seems expensive, you can pull up the exact prompt, response, token count, and cost in one place.

What This Changed Practically

I now route claude-haiku tasks through free models by default, and I've set up app-level routing so my quick chat window (the thing I use for "hey what's this error") hits the free path while Claude Code gets the full Sonnet model.

My monthly AI tool spend dropped roughly 40% without changing how I actually work.

The bigger change is more subtle: I stopped treating AI API costs as a fixed overhead I couldn't influence. Once you can see the breakdown, you start making different decisions about which model to reach for.

If you're running multiple AI coding tools and paying per-token for all of them, it's worth spending 10 minutes to actually look at where the spend goes. The answer might be more improvable than you'd expect.

CliGate is free and open source: github.com/codeking-ai/cligate

What does your current AI tool spend look like? Are you tracking it at all, or just paying the bill?

"I Pointed Claude Code at My Local Ollama Models — Here's the 3-Minute Setup"

CodeKing — Fri, 10 Apr 2026 07:35:13 +0000

My API bill last month had a line I couldn't ignore.

Not the expensive reasoning tasks — those I expected. It was the small stuff. The "what does this error mean" questions. The quick refactors. The five-line test I asked Claude Code to write at 11pm. A thousand tiny requests, all billed like they mattered.

Meanwhile, I had Ollama running on my machine with qwen2.5-coder loaded. Fast. Free. Already sitting there.

The problem was that my CLI tools had no idea it existed.

The Wiring Problem

Claude Code speaks Anthropic's protocol. Codex CLI speaks OpenAI's. Gemini CLI speaks Google's. And Ollama? It speaks its own thing — but it also exposes an OpenAI-compatible endpoint at http://localhost:11434.

So the question isn't "can Ollama do this" — it clearly can. The question is: how do you get your tools to talk to it without rewriting your entire config every time you switch between local and cloud?

That's what I spent the last week solving, and I've now shipped it as part of CliGate.

How It Works

CliGate is a local proxy that already handles routing Claude Code, Codex CLI, and Gemini CLI to cloud providers. The new local model support adds Ollama as a first-class routing target alongside OpenAI, Anthropic, and Google.

When local model routing is enabled, CliGate intercepts requests from your CLI tools and — depending on your config — sends them to Ollama instead of the cloud. Protocol translation happens in the proxy layer: Claude Code's Anthropic-formatted request gets adapted to whatever Ollama expects, the response gets adapted back.

Your tool never knows the difference.

The 3-Minute Setup

Step 1 — Make sure Ollama is running with a model

ollama run qwen2.5-coder:7b

Or any model you prefer. CliGate auto-discovers whatever's loaded.

# Verify Ollama is accessible
curl http://localhost:11434/api/version
# {"version":"0.6.x"}

Step 2 — Start CliGate

npx cligate@latest start

Dashboard opens at http://localhost:8081.

Step 3 — Add your Ollama instance

Go to Settings → Local Models. Add your Ollama URL:

http://localhost:11434

CliGate runs a health check and then fetches your model list via /v1/models. You'll see your loaded models appear automatically — no manual entry.

Step 4 — Enable local routing

Toggle on "Local Model Routing". At this point, any request that would normally go to a cloud provider will check local models first.

You can also configure this per-app. For example:

Claude Code → qwen2.5-coder:7b (your local coding model)
Codex CLI → cloud (when you need the full thing)
Gemini CLI → cloud

That's it. No ANTHROPIC_BASE_URL juggling. No re-exporting env vars. One dashboard toggle.

Step 5 — Test it

Go to the Chat tab, pick "Local Model" as the source, and send a message. If it comes back, the routing is working. Then go to your terminal and use Claude Code normally — the proxy handles the rest.

# Claude Code is already pointed at CliGate from the one-click setup
claude "explain what this function does"
# → routes to your local Ollama model

The Part That Surprised Me

I expected the basic routing to be the hard part. It wasn't.

The interesting problem was streaming. Claude Code expects streaming responses in Anthropic's SSE format. Ollama streams in its own format. Getting those two to handshake correctly without garbling the output took longer than everything else combined.

The solution is a dedicated SSE bridge in the proxy layer that reads Ollama's stream chunk-by-chunk and re-emits it in the format the requesting tool expects. Claude Code sees a normal Anthropic streaming response. It never touches Ollama directly.

Claude Code
  └─→ POST /v1/messages (Anthropic format, streaming)
        └─→ CliGate proxy
              └─→ detects: local routing enabled
              └─→ sends to Ollama /v1/chat/completions
              └─→ re-streams response as Anthropic SSE
        ←─ Claude Code receives: normal streaming response

Same pattern for Codex CLI (OpenAI Responses format) and any other tool you route through the proxy.

What This Is Actually Good For

I'm not suggesting you replace GPT-4 or Claude Sonnet with a local 7B model. There's a real capability difference.

But a lot of what I actually use Claude Code for in a normal day doesn't need the best model:

"What does this stacktrace mean?"
"Generate a unit test for this function"
"Rename these variables to be more descriptive"
"Does this SQL query look right?"

For tasks like these, qwen2.5-coder:7b is fast, accurate enough, and free. Saving the cloud calls for the harder problems — complex refactors, architecture questions, multi-file changes — drops my monthly API bill significantly without changing my workflow.

The toggle in CliGate makes it easy to switch back when you need to.

What's Your Local Model Setup?

Are you running Ollama (or LM Studio, or anything else) for coding tasks? I'm curious what models people are finding useful for day-to-day dev work — especially anything that runs well on a laptop.

GitHub: github.com/codeking-ai/cligate

npx cligate@latest start

"CliGate Now Has a Built-in AI Assistant That Can Configure Your Proxy For You"

CodeKing — Fri, 10 Apr 2026 07:08:13 +0000

Most local dev tools give you a config file and a README. If something breaks, you're on your own.

CliGate just shipped something different: a built-in AI assistant that lives inside the dashboard, understands the product, and can actually do things for you.

What Is CliGate Again?

CliGate is an open-source local proxy that sits between your AI coding tools and their APIs. You point Claude Code, Codex CLI, Gemini CLI, and OpenClaw at localhost:8081 — and CliGate handles routing, account pooling, protocol translation, and failover.

npx cligate@latest start

The dashboard opens at http://localhost:8081.

The New Chat Page

There's now a Chat tab in the dashboard.

On the surface it looks like a chat interface — and it is. You pick a credential source (a ChatGPT account, Claude account, or any API key you've added), choose a model, optionally set a system prompt, and start chatting. It's a useful testing surface for verifying that your credentials actually work before routing real CLI traffic through them.

But that's the boring part.

The Product Assistant Mode

Here's where it gets interesting.

Toggle on Product Assistant, and the chat behavior changes.

The assistant now has the full CliGate product manual loaded into its context. Ask it things like:

"How do I configure Codex CLI to use my Azure key?"
"What's the difference between Account Pool First and API Key First routing?"
"How do I enable free model routing?"

And it answers with actual, accurate information about this specific product — not generic AI hand-waving.

This is useful. CliGate has a lot of moving parts: multiple protocols, multiple account types, routing modes, model mapping, Gemini patching, free model fallback. Having an assistant that knows the system well enough to answer specific setup questions in plain language removes a lot of friction for new users.

The Action Mode: Chat That Does Things

This is the part that surprised me.

Type something like:

"Set up Claude Code to use the proxy"

And the assistant doesn't just tell you how. It shows you a confirmation card:

Enable Claude Code Proxy
Configure Claude Code to use the local proxy at http://localhost:8081.
[ Confirm ]

Click Confirm, and it actually writes the configuration to your Claude Code credentials — switching it to proxy mode, pointing it at localhost:8081, and mapping the model aliases.

Same in reverse: ask it to disable the proxy, and it confirms before restoring direct mode.

The token-based confirm step isn't just UX polish. It's a deliberate safety gate. The action token expires in 10 minutes. Nothing changes without your explicit confirmation. The assistant proposes, you approve, the action executes.

Why This Matters More Than It Looks

Most AI tools have chat interfaces.

Very few of them are product-aware assistants that can actually modify their own configuration on your behalf.

The gap between "I know how to fix this" and "I have just fixed this" is where most tool friction lives. CliGate's assistant collapses that gap for the most common setup operations — at least for Claude Code proxy toggle right now, with more actions likely coming.

The language support is also worth noting: the assistant detects whether you're asking in English or Chinese and responds accordingly. The intent detection and tool pattern matching work across both languages.

The Practical Loop

Here's what the workflow looks like now for a new user:

npx cligate@latest start
Open http://localhost:8081
Add an account or API key in the Accounts / API Keys tab
Go to Chat → enable Product Assistant
Ask: "How do I set up Claude Code to use this proxy?"
The assistant explains it, then offers to do it for you
Click Confirm
Done

That's a pretty clean onboarding path for what used to require navigating Settings, reading docs, and manually editing config files.

I Stopped Paying for AI CLI Chaos: This Local Gateway Makes Claude Code, Codex, and Gemini Work as One

CodeKing — Thu, 09 Apr 2026 07:08:09 +0000

If you are juggling Claude Code, Codex CLI, Gemini CLI, and random API keys across different providers, the setup gets ugly fast.

Different protocols. Different auth flows. Different config files. Different model names. Different rate limits.

So I built CliGate: a local multi-protocol AI gateway that sits on localhost and turns that mess into one controllable entry point.

Instead of wiring every tool separately, you point them at CliGate once and get:

multi-account pooling
API key failover
protocol translation
app-level routing
free-model fallback
a visual dashboard for everything

What CliGate actually does

CliGate is an open-source local proxy for AI coding tools and model APIs.

It currently supports:

Claude Code via Anthropic Messages API
Codex CLI via OpenAI Responses API, Chat Completions, and the Codex internal endpoint
Gemini CLI via Gemini API compatibility
OpenClaw via provider injection

That means one local service can sit between your tools and multiple upstream providers like OpenAI, Anthropic, Google Gemini, Vertex AI, and even free-model routes.

The real problem it solves

Most people do not have one clean AI stack.

They have:

a few accounts with different limits
some paid API keys
a CLI tool that only speaks one protocol
another tool that expects a completely different endpoint
no decent visibility into cost, usage, or failures

CliGate fixes that by separating the client protocol from the upstream provider.

Your tool can keep speaking the protocol it expects, while CliGate decides where the request should actually go.

The killer features

1. One gateway for multiple AI coding tools

You can run Claude Code, Codex CLI, Gemini CLI, and OpenClaw through the same local server.

No more maintaining a fragile pile of per-tool environment variables and scattered config files.

2. Account pools, not just API keys

CliGate is not just another API proxy.

It can manage:

ChatGPT account pools
Claude account pools
Antigravity accounts
provider API key pools

It supports OAuth login, token refresh, rotation strategies, quota tracking, and per-account management from the dashboard.

3. Smart routing instead of manual switching

You can choose:

account-pool-first
API-key-first
automatic routing
manual app assignment

So Claude Code can use one credential source, Codex can use another, and fallback behavior stays under your control.

4. Free-model routing for cheap or zero-cost workflows

One of my favorite parts is the ability to route lightweight requests such as claude-haiku to free models through Kilo AI.

That gives you a practical low-cost path for lightweight coding, testing, and background tasks without burning premium quota for everything.

5. A real dashboard instead of blind debugging

CliGate ships with a web UI where you can manage:

accounts
API keys
model mapping
per-app routing
request logs
usage and cost stats
pricing overrides
local tool installation and one-click configuration

This matters because most proxy tools become painful the moment you need to debug token expiry, failed routing, or mismatched models.

Why I think the protocol translation matters

This is the part that makes CliGate more than a credential switcher.

It exposes compatible endpoints for:

POST /v1/messages
POST /v1/chat/completions
POST /v1/responses
POST /backend-api/codex/responses
POST /v1beta/models/*

So tools that were never designed to share the same backend can still be managed through one local layer.

That unlocks a cleaner workflow:

Keep your preferred client.
Route it however you want.
Change upstream providers without rebuilding your whole local setup.

Local-first is the point

CliGate runs on localhost.

That means:

no third-party relay server
no hosted control plane
no forced telemetry layer
direct connections to official upstream APIs

For people who care about privacy, local control, or just not introducing another external dependency into their dev workflow, this is the right architecture.

Quick start

You can start it with:

npx cligate@latest start

Or install globally:

npm install -g cligate
cligate start

Then open:

http://localhost:8081

From there you can add accounts or API keys, map models, and configure your CLI tools to hit the local gateway.

Who this is for

CliGate is especially useful if you:

use more than one AI coding CLI
switch between Claude, OpenAI, Gemini, and other providers
want fallback behavior when limits or keys fail
want usage visibility across accounts and models
want a local control plane instead of ad hoc shell config

Repo

GitHub: https://github.com/codeking-ai/cligate

If you are building serious local AI coding workflows, this project is designed to remove a surprising amount of friction.

It is the difference between “a pile of disconnected AI tools” and “one local gateway that actually behaves like infrastructure.”

I Renamed My Open-Source Project and Doubled Its Discoverability — Here's Why "CliGate" Replaced "ProxyPool Hub"

CodeKing — Wed, 08 Apr 2026 08:15:59 +0000

The Problem: Nobody Could Find My Project

I built an open-source tool that manages multiple AI coding assistant accounts (Claude Code, Codex CLI, Gemini CLI) through a single local proxy. It had multi-account pooling, smart routing, a visual dashboard — everything a developer using AI tools needs.

But it had 12 stars. And when I Googled my own project name, I couldn't find it.

The name was "ProxyPool Hub." The problem? Search "proxypool" on GitHub and you get dozens of HTTP/IP proxy pool projects — web scraping tools with thousands of stars that completely buried mine. My AI coding tool was invisible because its name belonged to a different domain entirely.

The Fix: Rename to CliGate

After analyzing SEO patterns, checking npm/GitHub availability, and studying how successful open-source projects name themselves (LiteLLM, FastAPI, etc.), I renamed the project to CliGate — CLI + Gateway.

Why this name works:

7 characters — short, memorable, easy to type
CLI + Gate — instantly communicates "gateway for CLI tools"
Zero naming collisions — searching "cligate" returns only my project
Great CLI experience — npx cligate start feels natural
SEO-friendly — contains "cli" which matches what users search for

The GitHub org also changed from yiyao-ai (meaningless in English) to codeking-ai (memorable, professional).

What CliGate Actually Does

CliGate is a unified local gateway that sits between your AI coding CLIs and their APIs:

Claude Code / Codex CLI / Gemini CLI / OpenClaw
                    |
            CliGate (localhost:8081)
                    |
       +------------+------------+
       |            |            |
   ChatGPT      Claude       API Keys
   Accounts    Accounts     (10+ providers)

Core Features

Multi-Account Pooling

Add multiple ChatGPT, Claude, and Antigravity accounts
Auto-rotate when one hits rate limits (sticky, round-robin, or random)
OAuth login with automatic token refresh

API Key Management

Support for OpenAI, Azure OpenAI, Anthropic, Google Gemini, Vertex AI, MiniMax, Moonshot, ZhipuAI
One-click connectivity test
Automatic failover between keys

Smart Routing

Account Pool First or API Key First priority
Bind specific apps to specific credentials
Custom model mapping (e.g., route claude-haiku to free models)

Visual Dashboard

Real-time usage analytics and cost tracking
Full request/response logging
One-click CLI configuration for all supported tools
Built-in tool installer (Node.js, Claude Code, Codex, Gemini CLI, OpenClaw)
Dark/light theme, English/Chinese i18n

Quick Start

# No install needed
npx cligate@latest start

# Or install globally
npm install -g cligate
cligate start

Open http://localhost:8081 and you'll see the dashboard:

Lessons Learned About Naming Open-Source Projects

Your name IS your SEO — If your project name collides with established projects in a different domain, you're invisible
Include a domain keyword — "cli", "ai", "code" help search engines categorize your project correctly
Short beats descriptive — cligate > ai-llm-proxy-gateway-hub
Check availability everywhere — GitHub org, npm, Google results
Brand consistency matters — org name and project name should work together (codeking-ai/cligate)

"I Found the Underground Map of Free LLM APIs — Then Wired Them All Into One Proxy"

CodeKing — Tue, 31 Mar 2026 06:39:39 +0000

There are two kinds of developers in 2026.

The first kind is paying for every AI request like it's normal.

The second kind is quietly collecting free quotas, trial credits, OpenAI-compatible endpoints, Gemini access, Groq speed, random hidden gems, and stitching them together into one ridiculous local setup.

This post is for the second kind.

The Real Problem Isn't "Which Model Is Best?"

The real problem is this:

One provider gives you speed
Another gives you free credits
Another gives you decent coding models
Another looks promising but isn't integrated yet
And your tools? They all want different configs, different keys, and different endpoints

So your stack turns into a graveyard of:

half-used trial credits
forgotten API keys
rate-limited accounts
browser bookmarks you'll never open again

So I Built the Map

ProxyPool Hub now includes a Resources Catalog: a dedicated page that tracks free and trial LLM API platforms in one place.

Not just a dumb markdown list.

A real, filterable directory.

You can now browse a curated catalog of providers like:

OpenRouter
Google AI Studio
Groq
Cerebras
SambaNova Cloud
Hyperbolic
Scaleway Generative APIs
and more

Each entry includes:

whether it's free or trial
whether ProxyPool Hub already supports it
representative models
signup requirements
quota notes
compatibility details
whether it can be preset directly into the proxy

In other words:

it doesn't just tell you what's out there — it tells you what you can actually use right now.

This Is Where It Gets Dangerous (In a Good Way)

Because ProxyPool Hub isn't just a resource browser.

It's also the thing that lets you use those resources without losing your mind.

1. Free Model Routing

The new free model flow lets lightweight requests route to free providers automatically.

So instead of burning paid credits for every tiny task, you can push fast or low-cost workloads toward free-tier resources.

That means:

quick coding questions → free routes
lightweight model tasks → free routes
expensive reasoning jobs → your better accounts or keys

It's not just cheaper.

It changes your whole cost model.

2. Load Balancing Across API Keys

Most people use API keys like this:

Add one key
Use it until it breaks
Panic
Switch manually

ProxyPool Hub does the opposite.

It watches all your available keys and picks the one with the fewest requests first.

That's simple load balancing, but the practical effect is huge:

your keys last longer
rate limits hit later
traffic spreads out automatically
failures become much less noticeable

It feels less like "using an API key"

and more like running your own tiny inference mesh on localhost.

3. Pooling Accounts and Providers Like a Greedy Goblin

This is the part I like the most.

You don't have to marry one provider.

You can build a setup like this:

OpenRouter for rotating free models
Google AI Studio for Gemini access
Groq when you want stupid-fast responses
Cerebras when you want extra OpenAI-compatible capacity
SambaNova / Hyperbolic / Scaleway for trial credits
your own Claude / OpenAI / Azure accounts for the heavy jobs

Then point your tools at one local address.

That's the whole trick.

Your tools don't need to know your secret economy.

They just talk to the proxy.

4. The Catalog Is Actually Strategic

The smart part of the Resources Catalog isn't that it lists providers.

It's that it classifies them by practical usability:

supported → already works cleanly with ProxyPool Hub
presettable → can be slotted in with current patterns
candidate → promising, but needs extra adapter work
catalog only → good to know, not worth pretending it's plug-and-play yet

That's rare.

Most AI lists are fluff.

This one is operational.

It answers:

"Can I actually use this in my setup today?"

Why This Matters

Because the AI tooling world is getting weirder, not simpler.

Every month, new free endpoints appear.
Every week, quotas change.
Every day, someone discovers another provider with surprise credits and weird limits.

If you don't organize that chaos, you waste it.

ProxyPool Hub now gives you both sides of the game:

Discovery — find free/trial opportunities fast
Execution — route, pool, balance, and survive rate limits

The Vibe

This is no longer just "a proxy for Claude Code and Codex."

It's becoming something more interesting:

a local control plane for AI tool traffic.

One place to:

discover providers
compare quotas
pick usable free options
spread load across keys
route by app
preserve paid credits
keep your CLI tools working even when one provider taps out

Try It

npx proxypool-hub@latest start

Then open:

http://localhost:8081 → dashboard
http://localhost:8081/resources/ → free & trial resources catalog

"I Made AI Coding Tools Free (For Real This Time)"

CodeKing — Tue, 31 Mar 2026 05:47:45 +0000

The Problem

You know what's funny about "free" AI coding tools?

They're not free.

Codex CLI says it uses your OpenAI credits — and those run out fast. Claude Code says it uses Anthropic — and suddenly you're staring at "rate limited" at 2 PM on a Tuesday.

So much for "just works."

What If I Told You...

What if I told you there's a way to make Codex, Claude Code, Gemini CLI, and OpenClaw actually free?

Not "free tier" free. Not "limited to 50 requests" free. I'm talking free like WiFi at a coffee shop free.

The Secret: Free Model Routing

ProxyPool Hub now intercepts lightweight AI requests — the kind you'd use for quick code lookups, autocompletes, or "what does this error mean" — and routes them to actual free providers.

No API key. No credits. No billing.

When you need the heavy stuff (o4-mini, Sonnet 4, Gemini 2.5 Pro), it uses your paid accounts. When you just need a quick autocomplete? Free.

What Counts as "Free"?

Any model with "haiku", "mini", "fast", "lite" in the name gets auto-detected as a "fast" tier model
ProxyPool Hub maps those to free alternatives from providers like DeepSeek R1, Qwen3, or MiniMax
You can also manually specify which models route to free providers

The Toggle

One switch in the dashboard: "Enable Free Models." Flip it on. Done.

When it's on, fast-tier requests go to free providers. When it's off, everything goes through your accounts. It's that simple.

The Other Secret: Load Balancing Across API Keys

Here's something nobody talks about: API key load balancing.

You have 3 OpenAI keys? They're not all created equal. Key #1 might hit rate limit at 2 PM. Key #2 at 5 PM. Key #3 is barely used.

ProxyPool Hub now tracks:

Total requests per key
Rate limit cooldown status
Error history

And automatically routes to the least-used available key.

The Algorithm

// Simplified: pick the key with fewest requests
availableKeys.sort((a, b) => a.totalRequests - b.totalRequests);
return availableKeys[0];

That's it. When one key hits rate limit, it automatically tries the next. Your code doesn't know — or care — which key it's using.

But Wait, There's More

App-Specific Routing

You can now bind:

Codex → your Azure OpenAI endpoint (fastest)
Claude Code → your Claude Pro account
OpenClaw → any available key

Each app gets its own priority list of credentials. If the first choice is unavailable, it tries the second. If all fail and you enabled fallback, it falls back to the automatic pool.

8 Provider Support

We added 4 new providers since last time:

MiniMax
Moonshot (Kimi)
ZhipuAI (GLM)
Vertex AI

You can now mix and match across 8 different AI providers in a single dashboard.

The Real Cost

Let's do math.

Without ProxyPool Hub:

Claude Code → ~$20/month (Anthropic API)
Codex → ~$15/month (OpenAI)
Gemini CLI → $0 (free tier, limited)
Total: ~$35/month

With ProxyPool Hub:

Fast requests → Free (routed to free models)
Heavy requests → Your existing keys (shared across tools)
Total: $0/month (if you already have accounts)

The only "cost" is running a local Node.js process. That's it.

Setup (30 Seconds)

npx proxypool-hub@latest start

Open localhost:8081. Add your accounts. Flip the "Free Models" switch. Start coding.

The Catch

There isn't one.

It's 100% local — nothing leaves your machine
No telemetry, no tracking, no data collection
Credentials stored with restrictive file permissions
Runs on localhost — no cloud relay

Try It

GitHub · npm · Discord

Star it if it saves you money. Or don't. But at least try the free model routing — I dare you.

ProxyPool Hub: open-source under AGPL-3.0. Not affiliated with Anthropic, OpenAI, or Google.

"Stop Letting AI Tools Fight Over Your API Keys — Let a Smart Proxy Handle It"

CodeKing — Mon, 30 Mar 2026 08:42:34 +0000

Every AI coding tool wants its own API key. Its own config. Its own account.

Codex CLI wants OpenAI. Claude Code wants Anthropic. Gemini CLI wants Google. And you're sitting there with 5 browser tabs of API dashboards open, copy-pasting keys like it's 2019.

What if your tools never had to know where their tokens come from?

The Problem Nobody Talks About

You've got 3 ChatGPT accounts (don't pretend you don't). Two API keys. Maybe a Claude account. And every time you switch tools, you're manually rewiring the plumbing.

Worse — when one account hits its rate limit at 2 AM during a debug session, you're done. Go to bed. Try tomorrow.

That's not how this should work.

ProxyPool Hub: Your AI Traffic Controller

ProxyPool Hub is an open-source local proxy that sits between your AI tools and their APIs. Every tool points to localhost:8081, and the proxy figures out the rest.

npx proxypool-hub@latest start

One command. Dashboard at localhost:8081. Done.

But the latest release isn't just about pooling accounts anymore. It's about intelligent routing.

What's New: The Smart Routing Update

Bind Apps to Specific Credentials

This is the big one.

You can now tell ProxyPool Hub: "Always route Codex through my Azure OpenAI key. Always route Claude Code through my Claude account. Route everything else through the pool."

It's called App Assignments — and it changes how you think about API credentials.

Codex CLI → Azure OpenAI key (your fastest endpoint)
Claude Code → Claude account (your Pro subscription)
Gemini CLI → Gemini API key (your free tier)
OpenClaw → Whatever's available

Each app can have multiple fallback bindings. If binding #1 is rate-limited, it tries #2. If all fail and you've enabled fallback, it drops back to automatic rotation.

No more "wrong key for wrong tool" accidents.

Model Mapping That Actually Makes Sense

Instead of memorizing that gpt-4o should map to gemini-2.5-pro on Google or claude-sonnet-4-20250514 on Anthropic, ProxyPool Hub introduces tier-based mapping.

Four tiers: flagship, standard, fast, reasoning.

When Codex asks for gpt-4o, the proxy recognizes it as a "standard" tier model and maps it to whatever you've configured as your standard model on the target provider. New models auto-classify based on their names — no manual updates needed.

Codex Can See Images Now

This one's subtle but important. Codex CLI can read image files as part of its tool workflow. But Azure OpenAI uses a different image format (image_url) than what Codex sends (input_image).

ProxyPool Hub now transparently converts between all image formats — base64, URLs, data URIs — across all providers. Codex vision tasks just work, regardless of which backend you're routing through.

Free Model Toggle

Not every request needs GPT-4. The new Free Models switch routes lightweight requests (Haiku-tier) to free providers automatically. Turn it off when you need guaranteed quality. Turn it on to save money on code completions and quick lookups.

Built-in Chat

Sometimes you just want to test if your credentials work. The new dashboard chat lets you pick any credential source and start a streaming conversation — right in the browser. No CLI needed.

The Architecture (It's Simpler Than You Think)

Your AI Tools (Codex, Claude Code, Gemini CLI, OpenClaw)
                    |
            localhost:8081
                    |
         +----------+----------+
         |          |          |
    App Router   Model Map   Free Model
         |          |        Routing
         +----------+----------+
                    |
    +--------+------+------+--------+
    |        |      |      |        |
  ChatGPT  Claude  Azure  Gemini  Vertex
  Accounts Accounts OpenAI  API    AI

Every request gets:

Detected — which app sent it
Routed — to the assigned credential (or the pool)
Mapped — model name translated to the target provider
Translated — protocol converted (OpenAI ↔ Anthropic ↔ Gemini)
Delivered — with automatic retry on rate limits

It's 100% Local

Runs on localhost — nothing leaves your machine
Direct connections to official APIs — no relay servers
Zero telemetry, zero tracking
Credentials stored locally with restricted permissions

Get Started in 30 Seconds

# No install needed
npx proxypool-hub@latest start

# Or install globally
npm install -g proxypool-hub
proxypool-hub start

Open http://localhost:8081. Add your accounts or API keys. Click "Configure" next to your favorite CLI tool. Start coding.

I Built a Dashboard That Installs Claude Code, Codex & Gemini CLI in One Click

CodeKing — Fri, 27 Mar 2026 02:38:39 +0000

You know the drill. You want to try Claude Code. Then someone tells you about Codex CLI. Then Gemini CLI drops. Then there's OpenClaw.

Before you know it, you're juggling 4 different terminals, 4 different configs, and 4 different API keys — just to write code with AI.

What if you could manage all of them from one place?

Meet ProxyPool Hub

ProxyPool Hub is an open-source local proxy that sits between your AI coding tools and their APIs. It gives you:

A beautiful web dashboard at localhost:8081
Multi-account rotation (yes, you can use multiple accounts)
API key pooling with automatic failover
Free model routing (use Haiku-tier models for free via Kilo AI)
One-click configuration for every CLI tool

And in v1.0.6, it just got a lot more powerful.

What's New in v1.0.6

One-Click Tool Installer

Don't have Claude Code installed? Don't have Codex CLI? No problem.

The new Tool Installer tab detects your OS, checks what's installed, and lets you install everything with a single click:

Node.js — auto-detected, with platform-specific install guidance
Claude Code (@anthropic-ai/claude-code)
Codex CLI (@openai/codex)
Gemini CLI (@google/gemini-cli)
OpenClaw (openclaw)

Hit "Install All" and grab a coffee. Come back to a fully configured AI development environment.

API Key Test & Edit

Added an API key but not sure if it works? Now you can:

Test any key with one click — it hits the provider's API and tells you if it's valid
Edit key details inline — including Azure OpenAI deployment names, API versions, Vertex AI project IDs

No more deleting and re-adding keys just to fix a typo.

8 Provider Support

We now support API keys from:

OpenAI
Anthropic
Google Gemini
Azure OpenAI
Vertex AI
MiniMax
Moonshot (Kimi)
ZhipuAI (GLM)

All with automatic load balancing and failover. If one key hits a rate limit, the next one picks up seamlessly.

How It Works (30 Seconds)

npx proxypool-hub@latest start

That's it. Open http://localhost:8081. You'll see a dashboard where you can:

Add your accounts or API keys
Click "Configure" next to any CLI tool
Start coding

Every tool talks to ProxyPool Hub at localhost:8081, and it routes requests to the right provider with the right credentials.

Why Developers Love It

"I have 3 ChatGPT accounts and 2 API keys. ProxyPool Hub rotates between them automatically."

"I was paying for Claude API just to use Claude Code. Now I route haiku requests to free models and save $50/month."

"Setting up Codex CLI took me 20 minutes of config file editing. With ProxyPool Hub it was one button."

It's 100% Local

Runs entirely on localhost — nothing leaves your machine
Connects directly to official APIs — no third-party relay
Zero telemetry, zero data collection
Credentials stored locally with restricted file permissions

Get Started

# Quick start (no install needed)
npx proxypool-hub@latest start

# Or install globally
npm install -g proxypool-hub
proxypool-hub start

# Or download the desktop app
# https://github.com/yiyao-ai/proxypool-hub/releases

ProxyPool Hub: Use Claude Code, Codex CLI, Gemini CLI for Free with Multi-Account Pooling

CodeKing — Thu, 26 Mar 2026 02:31:24 +0000

What is ProxyPool Hub?

ProxyPool Hub is an open-source, multi-protocol AI API proxy server that lets you pool multiple free accounts to use popular AI coding assistants — without paying for API keys.

It supports:

Claude Code (Anthropic format)
Codex CLI (OpenAI Responses API)
Gemini CLI (Google Gemini API)
OpenClaw (Multi-provider)

Why?

Free-tier AI accounts have usage limits. When one account hits its limit, you have to wait. ProxyPool Hub solves this by rotating across multiple accounts automatically — when one is rate-limited, it seamlessly switches to the next.

Key Features

Multi-account pooling — Add multiple ChatGPT / Claude accounts, auto-rotate on rate limits
API key management — Bring your own API keys (OpenAI, Anthropic, Gemini, etc.) as fallback
Smart routing — Account-first or API-key-first priority, sticky or round-robin rotation
Protocol translation — Anthropic to OpenAI format conversion, so any client works with any backend
Visual dashboard — Web UI for account management, usage analytics, request logs, and model mapping
One-click setup — Configure Claude Code, Codex CLI, Gemini CLI, or OpenClaw with a single button
Free model access — Route haiku/small models to free providers (no account needed)

Quick Start

npm install -g proxypool-hub
proxypool-hub

Then open http://localhost:8081 to access the dashboard.

Architecture

The proxy receives requests in any supported format, translates them to the appropriate upstream API, and streams responses back — all transparently.

Claude Code / Codex CLI / Gemini CLI / OpenClaw
              |
       ProxyPool Hub (localhost:8081)
              |
    +---------+---------+
    |         |         |
 ChatGPT   Claude    API Keys
 Accounts  Accounts  (fallback)

Dashboard

The web dashboard provides:

Real-time account status and token expiry tracking
Usage analytics (per account, per model, daily/monthly)
Request logs with full request/response inspection
Model mapping configuration
One-click CLI configuration for all supported tools

Get Started

GitHub: github.com/yiyao-ai/proxypool-hub
npm: npm install -g proxypool-hub
Desktop: Download from GitHub Releases

Feedback, issues, and PRs are welcome!

ProxyPool Hub is licensed under AGPL-3.0.

DEV Community: CodeKing

"My Company Has Azure OpenAI. My AI Coding Tools Had No Idea What to Do With It."

What Makes Azure OpenAI Different

The Translation Problem

Setting It Up in CliGate

Why This Matters for Enterprise Teams

One Thing to Watch

"How I Route claude-sonnet-4-6 to GPT-5 Codex — Without Claude Code Knowing the Difference"

The Model Name Is a Routing Hint, Not a Destination

What CliGate Does With It

Why This Works

Setting This Up

The Part That Surprised Me

Why This Matters Beyond Cost

"My AI Coding Tools Were Running Up a Tab I Couldn't See — So I Fixed That"

The Problem With Opaque AI Billing

What I Did About It

The Bit I Didn't Expect: Some Models Are Just Free

The Details That Actually Changed My Behavior

What This Changed Practically

"I Pointed Claude Code at My Local Ollama Models — Here's the 3-Minute Setup"

The Wiring Problem

How It Works

The 3-Minute Setup

The Part That Surprised Me

What This Is Actually Good For

What's Your Local Model Setup?

"CliGate Now Has a Built-in AI Assistant That Can Configure Your Proxy For You"

What Is CliGate Again?

The New Chat Page

The Product Assistant Mode

The Action Mode: Chat That Does Things

Why This Matters More Than It Looks

The Practical Loop

Links

I Stopped Paying for AI CLI Chaos: This Local Gateway Makes Claude Code, Codex, and Gemini Work as One

What CliGate actually does

The real problem it solves

The killer features

1. One gateway for multiple AI coding tools

2. Account pools, not just API keys

3. Smart routing instead of manual switching

4. Free-model routing for cheap or zero-cost workflows

5. A real dashboard instead of blind debugging

Why I think the protocol translation matters

Local-first is the point

Quick start

Who this is for

Repo

I Renamed My Open-Source Project and Doubled Its Discoverability — Here's Why "CliGate" Replaced "ProxyPool Hub"

The Problem: Nobody Could Find My Project

The Fix: Rename to CliGate

What CliGate Actually Does

Core Features

Quick Start

Lessons Learned About Naming Open-Source Projects

Links

"I Found the Underground Map of Free LLM APIs — Then Wired Them All Into One Proxy"

The Real Problem Isn't "Which Model Is Best?"

So I Built the Map

This Is Where It Gets Dangerous (In a Good Way)

1. Free Model Routing

2. Load Balancing Across API Keys

3. Pooling Accounts and Providers Like a Greedy Goblin

4. The Catalog Is Actually Strategic

Why This Matters

The Vibe

Try It

Links

"I Made AI Coding Tools Free (For Real This Time)"

The Problem

What If I Told You...

The Secret: Free Model Routing

What Counts as "Free"?

The Toggle

The Other Secret: Load Balancing Across API Keys

The Algorithm

But Wait, There's More

App-Specific Routing

8 Provider Support