OpenAI Codex, the AI coding agent behind many developer workflows, now lets you plug in alternative language models instead of being locked into OpenAI's own offerings. Through a configuration file update, developers can route Codex through 300+ models on OpenRouter, run local models via Ollama, or send requests through internal company gateways. This flexibility arrives as the coding AI landscape fragments into competing tools and model providers, giving teams more control over cost, latency, and data handling.

What Changed in Codex's Configuration System?

The core change is straightforward but powerful: Codex now accepts a custom provider block in the ~/.codex/config.toml file. Instead of hardcoding requests to OpenAI's API, developers can specify a different base URL, authentication method, and API protocol. OpenRouter, the model routing platform, published a tutorial showing how to configure Codex to work through its service, which aggregates access to hundreds of language models.

The configuration requires three key pieces: a model_provider setting that names your custom connection, a base_url pointing to your chosen service, and a wire_api setting that tells Codex which API format to speak. For OpenRouter specifically, developers must set wire_api to "responses" to match the protocol OpenRouter uses. This separation of model selection from the agent interface means you can experiment with different models without rewriting your Codex commands or workflows.

Which Models Can You Actually Use With Codex?

The most immediate option is GLM-5.2, a newly released open-weight model from Z.ai that contains 753 billion parameters and can process up to 1 million tokens of context at once. GLM-5.2 leads the Artificial Analysis Intelligence Index and ranks second on the Code Arena WebDev leaderboard, making it a credible alternative to frontier proprietary models. However, the model is token-heavy, using 43,000 output tokens per task compared to 26,000 for its predecessor GLM-5.1, which means inference costs will be higher.

Beyond GLM-5.2, Codex can now point at OpenAI-compatible endpoints from providers like Mistral, local Ollama servers running smaller models, or internal LLM proxies that enterprises maintain for security and cost control. The flexibility comes with a trade-off: smaller local models may work fine for search, summaries, or mechanical edits, but they won't perform like frontier coding models on large refactors.

How to Configure Codex for a Custom Model Provider

• Choose a Provider ID: Pick a name for your custom provider (e.g., "glm_proxy," "company_gateway," or "local_ollama"), but avoid reserved names like "openai," "ollama," or "lmstudio," which Codex reserves for built-in providers.
• Set the Base URL: Point to your chosen service's API endpoint, such as https://api.example-glm-provider.com/v1 for a GLM-5.2 provider or http://localhost:11434/v1 for a local Ollama instance.
• Configure Authentication: Specify which environment variable holds your API key using the env_key setting, then export that key in your shell before running Codex commands.
• Add Optional Headers: If your provider requires extra headers for beta features, organization routing, or gateway authentication, use the http_headers or env_http_headers fields to pass them along.
• Test on Small Tasks First: Before running Codex on production refactors, test the provider connection with read-only commands, then try a minimal edit to confirm the model follows Codex's tool loop correctly.

The configuration pattern is the same across providers. If you're using GLM-5.2 through an OpenAI-compatible endpoint, you would set model = "glm-5.2", model_provider = "glm_proxy", then define the [model_providers.glm_proxy] section with your base_url and env_key. For Mistral, the pattern is identical except you'd use Mistral's API endpoint and model name.

Why This Matters for Teams and Enterprises

The most realistic use case is routing Codex through an internal company gateway. A platform team can own the LLM routing, budget controls, logging, and approved model list, while developers continue using Codex as normal. This centralizes spend tracking, enforces security policies, and prevents data from flowing directly to multiple vendor APIs. A developer would still run the same Codex commands, but the platform team controls which model actually processes the request and where the request goes.

Hugging Face released a benchmarking tool called agent-eval that measures agent effort in terms of tokens, time, and errors rather than just final accuracy. Testing revealed that adding a CLI and skill tier to the transformers library reduced work for large models but increased token usage for smaller models cloning the repository. This means library maintainers can now quantify the impact of API changes on agent efficiency, helping them balance documentation clarity against model capability.

OpenAI also demonstrated the practical value of agentic workflows in scientific research. The company partnered with Molecule.one to use GPT-5.4 and an autonomous agent to optimize Chan-Lam coupling reactions in medicinal chemistry. The system identified TEMPO as an effective additive, improving yields for 88% of boronic acids and 83% of sulfonamides. The workflow involved AI-generated hypotheses, automated high-throughput experimentation, and human validation at bench scale, showing how AI agents can accelerate experimental design when paired with human oversight.

What Are the Sharp Edges and Gotchas?

Several configuration mistakes can silently break your setup. If your model_provider name doesn't match the table name in your config file, Codex will ignore the provider entirely. If your env_key points to an unset environment variable, authentication will fail. If you use the wrong base_url (often missing or duplicating /v1), the provider will return a 404 error. One critical safety boundary: project-local.codex/config.toml files cannot override provider authentication, headers, or provider definitions. This prevents a repository from silently rerouting your agent to a different model service without your knowledge.

Another gotcha is API shape compatibility. Many providers advertise OpenAI-compatible chat completions, but some expose Responses-style APIs, and local Ollama often behaves like an OpenAI-compatible /v1 endpoint. Do not assume every model provider supports every Codex feature. If you point Codex at a chat-completions-style provider, provider-specific tuning knobs like model_verbosity may not work as expected.

The third sharp edge is model capability. A model can connect successfully and still be the wrong model for Codex. Testing a new provider on a production refactor is risky. Instead, start with a read-only command to confirm the provider connects, then try a small edit to verify the model follows Codex's editing loop, and finally inspect the output to decide whether the cost and latency justify using that model.

This shift toward pluggable model providers reflects a broader trend in AI tooling: as the market matures, developers want to choose their own models rather than being locked into a single vendor's stack. Codex's flexibility update gives teams the control to optimize for cost, performance, and compliance without abandoning their existing workflows.