Fable plans. Kimi K3 builds. Both inside Claude Code.

Get CLIProxyAPI running on :8317

Grab the binary (macOS/Linux/Windows) or run the Docker image. It starts a local Anthropic-compatible endpoint on port 8317. Docker is the set-and-forget option — it stays up across reboots:

# Docker (recommended — stays running)
docker run -d --name cli-proxy-api --restart unless-stopped \
  -p 8317:8317 \
  -v ~/cli-proxy/config.yaml:/CLIProxyAPI/config.yaml \
  -v ~/cli-proxy/auths:/root/.cli-proxy-api \
  eceasy/cli-proxy-api:latest

# or the binary — download from the releases page, then:
cli-proxy-api            # starts the server on :8317

One OAuth for Fable, one for Kimi

Each command opens a browser and stashes the token in ~/.cli-proxy-api. The first uses your existing Claude subscription (that's where Fable 5 comes from). The second logs in Kimi:

cli-proxy-api --claude-login    # your Claude sub → gives you Fable 5
cli-proxy-api --kimi-login      # your Kimi account → gives you Kimi K3

Give the proxy a key of its own

In config.yaml, add an api-keys entry — invent any string. That's the bearer token Claude Code will use to talk to the proxy. If you're going the API-key route for Kimi (not --kimi-login), add the Moonshot block too, and restart:

# config.yaml
port: 8317

# the key YOUR tools use to reach the proxy — make one up
api-keys:
  - "sk-local-kimi-worker"

# ONLY if you're using a Moonshot API key instead of --kimi-login:
claude-api-key:
  - api-key: "sk-YOUR-MOONSHOT-KEY"
    base-url: "https://api.moonshot.ai/anthropic"
    models:
      - name: "kimi-k3"

Two env vars send traffic to the proxy

Set these in your shell (or a .env you source before launching Claude Code). ANTHROPIC_AUTH_TOKEN sends your key as a Bearer header — that's the one the proxy expects, not ANTHROPIC_API_KEY:

export ANTHROPIC_BASE_URL=http://localhost:8317
export ANTHROPIC_AUTH_TOKEN=sk-local-kimi-worker

Fable on the opus tier, Kimi on sonnet

Claude Code has three model tiers — opus, sonnet, haiku. You remap what each one resolves to, so the planner tier is Fable and the worker tier is Kimi. opusplan mode then plans on the opus tier and executes on the sonnet tier — exactly the split you want. Subagents get Kimi too:

# the brain
export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-fable-5
# the hands
export ANTHROPIC_DEFAULT_SONNET_MODEL=kimi-k3
export CLAUDE_CODE_SUBAGENT_MODEL=kimi-k3

# housekeeping for a non-Anthropic worker model:
export ENABLE_TOOL_SEARCH=false          # off by default on a custom endpoint
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576   # use Kimi's full 1M window

Then, inside Claude Code, flip the mode and check it took:

/model opusplan     # Fable plans → Kimi K3 executes
/status             # confirms base URL + auth token are pointed at the proxy

Plan with Fable, ship with Kimi

Start any task in plan mode. Fable 5 reads the codebase, argues the approach, and writes the plan. The moment you accept it, Claude Code drops to the sonnet tier — Kimi K3 — and does the actual edits, file writes, and test runs. You review; Fable comes back for the calls that need judgment.

Fan the grunt work out to Kimi subagents

Because CLAUDE_CODE_SUBAGENT_MODEL=kimi-k3, every subagent you spawn runs on Kimi. So for anything wide and mechanical — "search these 40 files", "write tests for each of these modules" — dispatch subagents and let Kimi's cheap tokens absorb it while Fable stays free for the thinking.

“Spawn a subagent per file to add JSDoc to every exported function in src/lib, then report back a summary.”

Force one model when you want to

opusplan is the automatic version, but you can override any time. /model sonnet pins everything to Kimi K3 for a cheap, all-hands session; /model opus pins it to Fable when you're doing something delicate and don't want the cheap model near it. Flip back to opusplan for the balanced default.