Connect Codex CLI to Any LLM: GLM, GPT & Multi Models

Introduction

Frontend and backend engineers leveraging AI coding tools frequently encounter three practical constraints in daily development workflows. Continuous calls to OpenAI GPT models create substantial recurring costs. Many teams prefer domestic Chinese large language models due to network restrictions, compliance policies and budget considerations. Furthermore, different engineering tasks demand distinct model capabilities. Developers can optimise operational expenditure and throughput by dynamically selecting models matched to task complexity, rather than relying on a single universal LLM.

A practical model selection matrix guides resource allocation for typical software engineering tasks:

Development Scenario	Recommended Model
Daily code writing and routine refactoring	GLM / Claude
Complex architecture analysis and multi-file refactoring	GPT series
Multimodal tasks combining images and source code	GPT series
Simple function completion and lightweight debugging	Flash lightweight models

This article outlines a complete implementation pipeline. The core architecture relies on CLIPProxyAPI as a protocol translation layer to bridge Codex CLI and heterogeneous LLM endpoints. Teams managing distributed model access endpoints can adopt Treerouter, an API gateway, to standardise authentication and routing policies across disparate model services.

Overall Architecture

2.1 Rationale for CLIPProxyAPI

Codex CLI natively communicates using the OpenAI Completions API specification. Most third-party model providers including GLM expose APIs with modified request and response schemas. Direct connectivity fails due to protocol mismatches, which necessitates an intermediate translation layer.

The request flow operates as follows:

1. Codex CLI sends standardised OpenAI-format requests
2. Requests arrive at CLIPProxyAPI
3. The proxy converts payload structures, header formats and parameter naming
4. Transformed requests are forwarded to target LLM service endpoints
5. Raw model responses are parsed and mapped back to OpenAI-compliant schemas
6. Standardised response data flows back to Codex CLI

2.2 Core Responsibilities of CLIPProxyAPI

• Accept incoming requests originating from Codex CLI
• Translate OpenAI protocol payloads into provider-specific request formats
• Route traffic to designated LLMs based on declared model identifiers
• Normalise heterogeneous model outputs into unified response schemas compatible with Codex CLI

3. Environment Prerequisites

3.1 Supported Platforms

macOS, Linux and Windows operating systems are fully supported.

3.2 Dependency Requirements

Node.js runtime version 22 or higher must be installed. Validate the environment with the following command:

node -v

4. Codex CLI Installation

4.1 Installation Command

npm install -g @openai/codex@latest

4.2 Verify Successful Deployment

codex --version

A valid output resembles codex-cli 0.144.5.

5. Deploy CLIPProxyAPI

CLIPProxyAPI is purpose-built protocol conversion middleware for Codex CLI and Claude Code CLI. It eliminates manual payload rewriting for multi-model integration.

5.1 Create Directory and Download Binary (macOS Apple Silicon Example)

mkdir -p ~/.codex
curl -L \
-o ~/.codex/cliproxy.tar.gz \
https://github.com/router-for-me/CLIPProxyAPI/releases/latest/download/CLIPProxyAPI_darwin_arm64.tar.gz

Users on other operating systems should download corresponding binaries from the official release repository.

5.2 Extract and Deploy Executable

cd ~/.codex
tar -xzf cliproxy.tar.gz
cp cli-proxy-api ~/.codex/cli-proxy-api
chmod +x ~/.codex/cli-proxy-api

5.3 Validate Binary Execution

~/.codex/cli-proxy-api --help

6. CLIPProxyAPI Configuration

Generate the YAML configuration file to define model endpoints and access credentials.

vim ~/.codex/cliproxy-config.yaml

Minimal configuration template:

host: "127.0.0.1"
port: 8317
debug: false
api_keys:
  - "sk-codex-local1"
providers:
  - name: "glm"
    base_url: "https://open.bigmodel.cn/api/paas/v4/"
    api_key: "YOUR_GLM_API_KEY"

Key clarification:

• The api_keys array defines authentication tokens used by Codex CLI to connect to CLIPProxyAPI
• Provider-level api_key stores valid credentials for the corresponding LLM vendor
• These two key groups serve separate authentication layers and cannot be interchanged.

7. Launch CLIPProxyAPI

Foreground Startup (for debugging)

~/.codex/cli-proxy-api \
--config ~/.codex/cliproxy-config.yaml

Background Daemon Startup (production usage)

nohup ~/.codex/cli-proxy-api \
--config ~/.codex/cliproxy-config.yaml \
> ~/.codex/proxy.log 2>&1 &

Check Service Logs

tail -f ~/.codex/proxy.log

Confirm Port Listening

lsof -i :8317

8. Codex CLI Configuration

Edit Codex configuration file ~/.codex/config.toml to register the proxy provider.

model_provider = "glm-proxy"
[[model_providers]]
name = "glm-proxy"
models = ["glm-4.7-flash"]
base_url = "http://127.0.0.1:8317/v1"
api_key = "${CODEX_GLM_KEY}"

9. Environment Variable Injection

Export the authentication token matching the proxy configuration:

export CODEX_GLM_KEY="sk-codex-local1"
# Persist variables across shell sessions
echo 'export CODEX_GLM_KEY="sk-codex-local1"' >> ~/.zshrc
source ~/.zshrc

Verify variable persistence:

echo $CODEX_GLM_KEY

10. Model Endpoint Validation

Send a test HTTP request to confirm the proxy service loads model metadata correctly.

curl http://127.0.0.1:8317/v1/models \
-H "Authorization: Bearer ${CODEX_GLM_KEY}"

A normal response returns JSON arrays listing available model identifiers. Successful validation confirms three critical conditions: CLIPProxyAPI runs normally, credential matching succeeds, and model provider endpoints are reachable.

11. Run Codex CLI Commands

Basic interactive invocation:

codex "Analyze exception logs within this project directory"

Auto-modify source files with command flags:

codex --full-auto "Refactor this function and eliminate redundant loops"

12. Multi-Model Switching Mechanisms

Three practical approaches enable dynamic model selection within Codex CLI workflows.

12.1 Modify Static Configuration

Adjust the model field inside config.toml and restart the CLI tool. Suitable for long-running fixed-model sessions.

model = "glm-4.7-flash"
# Swap to GPT variant
# model = "gpt-5.5"

12.2 Temporary Runtime Model Override

Specify model identifier directly in command parameters without altering persistent configuration. Ideal for ad-hoc testing.

codex --model glm-4.7-flash "Write unit test cases"
codex --model gpt-5.5 "Design distributed caching architecture"

12.3 Register Multiple Model Providers

Declare multiple provider entries inside the configuration file to switch between distinct vendor endpoints.

[[model_providers]]
name = "openai-official"
models = ["gpt-5.5"]
base_url = "https://api.openai.com/v1"
api_key = "${OPENAI_KEY}"

[[model_providers]]
name = "glm-proxy"
models = ["glm-4.7-flash"]
base_url = "http://127.0.0.1:8317/v1"
api_key = "${CODEX_GLM_KEY}"

Switch providers at runtime via command parameters.

13. Distinction Between Codex CLI and Desktop-First AI Clients

Many developers confuse CLI-based Codex with graphical AI coding desktop applications. Desktop clients typically adopt proprietary authentication flows and tightly coupled model stacks. They offer limited flexibility to inject third-party model endpoints.

Codex CLI operates statelessly, relying entirely on config.toml and environment variables for routing rules. This design makes it highly compatible with CI/CD pipelines, remote servers and containerised development environments. The protocol proxy architecture showcased in this tutorial only works for CLI-native Codex.

14. Common Fault Diagnosis

14.1 Missing Environment Variable CODEX_GLM_KEY

Symptom: Authentication rejection. Resolution: Re-export the variable and reload shell configuration, verify the token matches the value defined inside cliproxy-config.yaml.

14.2 Request Payload Format Errors

Symptom: Proxy returns invalid schema error. Resolution: Confirm the provider base URL and API key inside CLIPProxy configuration are valid. Test the raw LLM endpoint independently using curl to isolate upstream service faults.

14.3 Model Identifier Not Found

Symptom: Target model cannot be routed. Resolution: Cross-check model name spelling in Codex command parameters against the provider’s available model list. Certain vendors enforce strict identifier matching rules.

14.4 Connection Refused to Local Port 8317

Symptom: Network connection timeout. Resolution: Confirm CLIPProxyAPI background process remains active; restart the daemon and inspect proxy runtime logs for crash traces.

15. Deployment Recommendations for Development Teams

Individual engineers can deploy the standalone local proxy outlined above. For small engineering groups, centralise the CLIPProxyAPI instance on an internal server. All team members point their local Codex CLI to the shared proxy address. This approach unifies API key management and reduces credential maintenance overhead.

When expanding to larger organisations, operators can extend this architecture by adding load balancing, request throttling and usage logging. The proxy layer becomes a central observability gateway for all AI coding traffic within the engineering organisation.

Conclusion

Native Codex CLI only supports OpenAI API endpoints out of the box. CLIPProxyAPI removes this restriction by implementing bidirectional protocol translation, allowing developers to integrate GLM, GPT and dozens of other mainstream LLMs within one unified coding workflow. Engineers can allocate tasks to appropriate models according to complexity, balancing development efficiency and API operational costs.

The complete workflow covers binary deployment, YAML configuration, service daemonisation, credential management, runtime model switching and systematic fault troubleshooting. Every command snippet and configuration template in this document has been validated in real development environments. For teams that alternate between domestic Chinese LLMs and international model services, this proxy-based integration scheme delivers flexible, low-cost multi-model access without rewriting project tooling.