Models & Providers

Gee-Code supports Bring Your Own Provider (BYOP) — you’re not locked into a single AI. Use built-in providers, add custom API-compatible endpoints, or wrap CLI tools as providers.

Built-in Providers

Provider	Models	Auth
Anthropic	Claude Opus, Sonnet, Haiku	ANTHROPIC_API_KEY
OpenAI	GPT-4o, o1, o3	OPENAI_API_KEY
Google	Gemini Pro, Flash	GOOGLE_API_KEY
xAI	Grok	XAI_API_KEY
Groq	Fast inference (Llama, Mistral)	GROQ_API_KEY
Cerebras	Ultra-fast inference	CEREBRAS_API_KEY
OpenRouter	Multi-provider routing (hundreds of models)	OPENROUTER_API_KEY
Perplexity	Sonar models	PERPLEXITY_API_KEY
Ollama	Local models (DeepSeek, Llama, Mistral)	None (local)

Switching Models

/model sonnet          # Claude Sonnet (fast, capable)
/model opus            # Claude Opus (most capable)
/model haiku           # Claude Haiku (fastest, cheapest)
/model gpt4o           # GPT-4o
/model gemini          # Gemini Pro
/model ollama/llama3   # Local Ollama model
/models                # List all available models

Model Resolution

When you type /model sonnet, the resolution chain is:

1. Exact match — check known model IDs directly
2. Alias lookup — map short names to full IDs (sonnet -> claude-sonnet-4-5-20250929)
3. Provider prefix — claude* routes to Anthropic, gpt* to OpenAI
4. Custom providers — checked last

Model Clamping

Force all AI calls to use a specific model — including sub-agents, RLM queries, and bead execution.

Session Clamping

Affects only the current session:

/clamp sonnet          # This session uses Sonnet for everything
/clamp off             # Return to normal routing

Global Clamping

Affects all Gee-Code instances — every running session and every new session inherits the clamp:

/clamp all-on haiku    # Force ALL instances to use Haiku
/clamp all-off         # Remove the global clamp

Global clamping persists to your configuration file, so it survives restarts. It also adjusts iteration limits based on the model tier — cheaper models get higher iteration budgets.

Use global clamping when you want to control costs across autonomous Gees that are running in the background, or when testing how your entire system behaves on a single model.

Custom Providers

Add any OpenAI-compatible API:

/provider add

This opens an interactive configurator where you set:

Field	Description
name	Display name (e.g., “Local Ollama”)
base_url	API endpoint (e.g., http://localhost:11434/v1)
api_key	Auth token (or "none" for local)
models	List of model IDs available
default_model	Default model when this provider is selected

Compatible APIs

Any API implementing the OpenAI chat completions format works:

• Ollama — http://localhost:11434/v1
• LM Studio — http://localhost:1234/v1
• vLLM — custom endpoint
• Azure OpenAI — with appropriate base URL and API version
• Any self-hosted OpenAI-compatible server

Using Claude Code with Your Max Plan

If you have a Claude Code Max subscription, you can use it as a provider in Gee-Code — no API key needed.

Step 1: Check Provider Status

/providers browse

This opens the interactive provider browser. Look under the CLI/BYOP tab for the Claude Code entry. If status shows ok in green, you’re ready. If not, continue to Step 2.

Step 2: Install Claude Code CLI

If Claude Code isn’t installed yet:

curl -fsSL https://claude.ai/install.sh | bash

Then run claude in your terminal and select “Use subscription” when prompted. This links your Max plan to the CLI.

Step 3: Verify Setup

Go back to the provider browser:

/providers browse

You should now see ok in green next to the Claude Code provider.

Step 4: Activate Claude Code

Use /clamp to route all Gee-Code AI calls through your Claude Code subscription:

Command	What it does
/clamp on cc	Vanilla Claude Code — adaptive effort level
/clamp on cc-gee-max	Max reasoning effort with full Gee tools

cc runs Claude Code with adaptive effort — good for everyday tasks. cc-gee-max forces max reasoning effort (Opus 4.6) and enables all Gee MCP tools — best for complex, multi-step work.

To stop routing through Claude Code:

/clamp off

CLI Providers

Wrap command-line tools as providers — any process that reads stdin and writes stdout:

{
  "type": "cli",
  "command": "claude",
  "args": ["--model", "opus"],
  "working_dir": "/path/to/project"
}

This lets Gee-Code delegate to other AI tools as sub-providers. CLI providers run as child processes, so they get their own MCP server instance with full tool access.

Identity in BYOP

When a Gee runs through a CLI provider, its identity propagates automatically. The daemon injects GEE_MODE_NAME into the child process environment, and the MCP server reads it on startup — so tools like SendNotification know which Gee is speaking without extra configuration.

The resolution chain for identity:

1. Explicit parameter — gee_name passed directly to the tool
2. Environment — GEE_MODE_NAME (set by daemon for CLI providers)
3. In-process context — the active mode from the mode manager
4. Fallback — defaults to "gee"

This means a Gee running on Claude via Anthropic’s native provider and the same Gee running through a CLI-wrapped provider both resolve identity correctly. Notifications carry the right name, replies route to the right inbox.

Credentials

API keys resolve through a multi-source chain:

1. Credentials store — scoped to gee/team/endeavor
2. Local file — ~/.gee-code/credentials.json
3. Environment variables — ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
4. Gee backend — your stored credentials on the platform

/credentials              # Show all credential status
/credentials set openai   # Set an API key

Per-Agent Models

Different agents can use different models. An architect agent might use Opus for deep reasoning, while an explorer agent uses Haiku for speed:

---
name: my-architect
model: claude-opus
---

When running flights or swarms, each agent uses its configured model unless /clamp overrides it.

Next Steps

• Agents & Delegation — specialized agent types
• Planning & Execution — task decomposition with beads
• Configuration — model and provider settings