Model Backends

Claude Code talks to an API endpoint. Override ANTHROPIC_BASE_URL and the model resolves to whatever that endpoint serves. Your skills, MCP servers, hooks, memory, and CLAUDE.md all load normally — the model is just the brain, everything else is the same.

Three providers offer native Anthropic-compatible API endpoints — no third-party proxy like LiteLLM or OpenRouter needed. Your requests go directly to the provider's servers, though latency is still higher than native Claude MAX due to the additional network hop:

Create a file that defines aliases for each backend. Source it from your shell profile so it survives reboots. Each alias launches the same claude binary with different environment variables.

# GLM — GLM-5.1 on opus, GLM-4.7 on sonnet/haiku/subagents
# 200K context, z.ai coding plan
alias claude-glm='ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic" \
  ANTHROPIC_API_KEY="your-glm-api-key" \
  ENABLE_TOOL_SEARCH=false \
  ANTHROPIC_DEFAULT_OPUS_MODEL="GLM-5.1" \
  ANTHROPIC_DEFAULT_SONNET_MODEL="GLM-4.7" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL="GLM-4.7" \
  ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="GLM-5.1" \
  ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="GLM-4.7" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="GLM-4.7" \
  CLAUDE_CODE_SUBAGENT_MODEL="GLM-4.7" \
  CLAUDE_CODE_MAX_OUTPUT_TOKENS="32000" \
  CLAUDE_CODE_AUTO_COMPACT_WINDOW="180000" \
  CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1" \
  CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS="1" \
  API_TIMEOUT_MS="3000000" \
  claude'

# Kimi K2.5 (Moonshot) — subscription plan ($30/mo), 262K context
alias claude-kimi='ANTHROPIC_BASE_URL="https://api.kimi.com/coding/" \
  ANTHROPIC_API_KEY="your-kimi-api-key" \
  ENABLE_TOOL_SEARCH=false \
  ANTHROPIC_DEFAULT_OPUS_MODEL="kimi-for-coding" \
  ANTHROPIC_DEFAULT_SONNET_MODEL="kimi-for-coding" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL="kimi-for-coding" \
  ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="Kimi K2.5" \
  ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="Kimi K2.5" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="Kimi K2.5" \
  CLAUDE_CODE_SUBAGENT_MODEL="kimi-for-coding" \
  CLAUDE_CODE_MAX_OUTPUT_TOKENS="32000" \
  CLAUDE_CODE_AUTO_COMPACT_WINDOW="230000" \
  CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1" \
  CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS="1" \
  API_TIMEOUT_MS="3000000" \
  claude'

# Qwen 3.6 Plus (Alibaba Cloud Coding Plan) — $50/mo, multi-model plan
# Also bundles kimi-k2.5, glm-5, MiniMax-M2.5 under the same API key
alias claude-qwen='ANTHROPIC_BASE_URL="https://coding-intl.dashscope.aliyuncs.com/apps/anthropic" \
  ANTHROPIC_API_KEY="your-alibaba-coding-plan-key" \
  ENABLE_TOOL_SEARCH=false \
  ANTHROPIC_DEFAULT_OPUS_MODEL="qwen3.6-plus" \
  ANTHROPIC_DEFAULT_SONNET_MODEL="qwen3.6-plus" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL="qwen3.6-plus" \
  ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="Qwen 3.6+" \
  ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="Qwen 3.6+" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="Qwen 3.6+" \
  CLAUDE_CODE_SUBAGENT_MODEL="qwen3.6-plus" \
  CLAUDE_CODE_MAX_OUTPUT_TOKENS="32000" \
  CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1" \
  CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS="1" \
  API_TIMEOUT_MS="3000000" \
  claude'

# Load AI aliases
[ -f "$HOME/.ai-aliases.zsh" ] && source "$HOME/.ai-aliases.zsh"

What the extra env vars do

Authentication precedence

Claude Code checks credentials in this order: ANTHROPIC_AUTH_TOKEN > ANTHROPIC_API_KEY > OAuth login. Either variable works in your aliases — ANTHROPIC_API_KEY is sufficient and avoids overwriting the OAuth token. You'll see a one-time auth prompt on first launch; approve it and the session uses the API key cleanly.

Shell environment variables always override settings.json. No config file conflicts between backends — your regular claude command keeps using MAX, and each alias overrides cleanly.

Each backend has different strengths, context limits, and cost profiles. Pick the right one for the task.

Non-interactive mode (claude -p) works with any backend alias. Pipe a task in, get results out. Delegate batch work to alternative backends to save your MAX tokens for complex interactive sessions.

# Code review on GLM (coding plan)
git diff | claude-glm -p "Review this diff for bugs and security issues"

# File analysis on Kimi tokens (subscription)
claude-kimi -p "Explain the architecture of src/auth/" \
  --allowedTools "Read,Grep,Glob"

# Structured output for CI pipelines
claude-glm -p "List all TODO comments in this repo" \
  --output-format json \
  --allowedTools "Grep"

Cross-backend delegation from an active session

Inside any Claude Code session, you can shell out to another backend using the ! prefix:

# From a GLM session, delegate a complex task to Opus
! claude -p "Analyze the security of src/auth.ts" --allowedTools "Read,Grep"

# From a Claude MAX session, hand off a review to Kimi
! git diff | claude-kimi -p "Review for OWASP top 10 issues"

The first task given to GLM-5.1 through Claude Code was a natural language game concept — a top-down zombie survival shooter inspired by Alien Swarm and Shaun of the Dead. The prompt was a casual brain dump, not a structured spec.

What GLM produced

• Phaser 3 with arcade physics, zero-gravity top-down movement
• Procedural pixel art sprites generated at runtime — no external assets
• Wave-based zombie AI with 4 variants and escalating difficulty
• Collision detection, health bar, ammo counter, score tracker
• Real-time minimap with zombie positions
• Blood splats, screen shake, muzzle flash, death animations
• 4 checkpoints across a procedurally generated town map
• Complete README with 5-phase roadmap

All MCP servers (code search, memory, file operations) worked correctly throughout the session. GLM used context7 to look up Phaser 3 documentation, Read/Write/Edit for file operations, and ran the same /wrap end-of-session workflow that Claude does. Tool use reliability was indistinguishable from a native Claude session for this task.

Beyond prototyping — GLM-5.1 running /pr-resolve on a real pull request. Discovering review threads, creating patches, pushing branches, managing git worktrees. Full MCP tool chain: GitHub API, file operations, git commands.

Top pane: GLM resolving PR review threads — reading comments, patching code, pushing fixes. Bottom pane: Claude Sonnet running Playwright tests and managing worktrees on a different project. Two models, two projects, running simultaneously on the same machine.

Same night, harder prompt. Kimi K2.5 was given a similar brain dump but asked for a side-scrolling shooter (Metal Slug style) instead of top-down. Side-scrollers are objectively more complex — gravity, jump arcs, platform collision, directional shooting, parallax scrolling.

Honest comparison

GLM shipped a working top-down game in one shot. Kimi needed three debugging rounds for the harder side-scroller. Neither result is directly comparable — the prompts were different, the complexity was different. A fair benchmark would use identical specs, which is planned for a future test.

What both results prove: alternative models can navigate Claude Code's full tool chain — file creation, MCP servers, Phaser documentation lookup, multi-file editing — and produce working software. The quality gap between models shows up in edge cases and debugging resilience, not in basic capability.

GLM token burn: ToolSearch incompatibility

Claude Code's deferred tool loading feature (ENABLE_TOOL_SEARCH, enabled by default) lets the model lazily fetch tool schemas on demand. GLM does not handle this flow natively — it loops on ToolSearch calls, burning millions of tokens on repeated schema fetches instead of resolving them. The fix is ENABLE_TOOL_SEARCH=false in your alias, which dumps all tool schemas upfront. The tradeoff: 60-70% of your context window is consumed at session start by ~100 MCP tool schemas. To reduce this, disable MCP servers you don't need for the task. This is a Claude Code compatibility issue with non-Anthropic backends, not a GLM API limitation — it may be resolved in a future Claude Code update.

Context limits are the real constraint

A fully-loaded Claude Code session (~82K tokens of system prompt) needs a model with enough context headroom. GLM (200K) and Kimi (262K) handle this fine. Models with smaller windows may need --bare mode, which strips plugins, skills, and MCP servers.

No mid-session switching

You cannot change backends during a conversation. Each terminal session is locked to whatever backend it launched with. To use a different model, open a new terminal tab.

Latency

Alternative backends talk directly to the provider's API (no third-party proxy), but the additional network hop still adds latency. Expect noticeably slower first-token and streaming response times compared to native Claude MAX, which benefits from Anthropic's optimized infrastructure and prompt caching.

Tool use reliability varies

Claude is purpose-built for Claude Code's tool calling patterns. Alternative models may struggle with complex multi-step tool chains (Read → Edit → Grep → Bash sequences). GLM-5.1 tested well on a substantial scaffolding task, but long-session reliability for all backends is still being evaluated.

Auth conflict on first launch

If you're logged into claude.ai (MAX subscription), launching an alias will show a one-time warning about conflicting credentials. Approve the API key when prompted — it takes precedence for that session. This is cosmetic; both ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN work correctly.

Shell aliases give you one model per terminal. OpenCode (open source, 75+ providers) lets you switch models mid-session with Ctrl+O. It reads your CLAUDE.md and ~/.claude/skills/ natively — same skills, same MCP servers, different UI.

These API keys work anywhere. The shell aliases and dedicated CLIs are the convenience layer — not the only integration point.