Use open models in Claude Code, Codex, Cursor and Copilot

Can I keep Claude Code, Codex, Cursor or Copilot when I switch to open models? The question comes up because your team already knows these tools and the model is the part you want to change. Model quality is less of a worry. Since January 2026 the most capable open models have lagged frontier closed models by about four months. That leaves tool fit as the open question.

We are Lyceum, a sovereign European AI inference provider for open-source models. Our serverless models run in Paris and Finland, and prompts and outputs are processed, not stored. This article covers what our documentation says about each tool, where it stops, and how to test before you move the team.

List the coding features your team must retain

Start with features, not tools. A coding tool bundles several features, and a custom model may reach only some of them. Name the ones your team uses every day.

Four matter here. Chat answers questions about your code in a side panel. Agent mode lets the tool edit several files and run commands in a loop: it reads, edits, runs a test, reads the result and repeats. Inline completion suggests the next lines as you type. Tool calling is how a model asks the tool to act, by returning an action name and its arguments in a fixed format.

Our worked example uses a hypothetical team that needs three of these: chat, agent edits and inline completion. The team is invented. The tool limits come from our docs, read on 20 October 2026. Score each tool with one ratio:

coverage = features the tool sends to your model / features you need

A score below 1 does not rule a tool out. It tells you which feature stays on the vendor's own model.

Match each tool to its documented endpoint route

An endpoint is the web address a tool sends its requests to. We serve open models through two. Most tools use our OpenAI-compatible endpoint, which accepts requests in OpenAI's format. Claude Code uses our Anthropic-compatible endpoint, which accepts requests in Anthropic's format, as our coding agents overview explains. Both sit on our serverless inference, billed per token with no base fee.

For Claude Code, the recommended route is our command-line tool. The `lyceum code` command starts Claude Code with our endpoint already set, in its own profile that never touches an existing Anthropic login. The Claude Code page has the details.

pip install lyceum-cli
lyceum auth login --api-key lk_<your_api_key>
lyceum code

To try it in one terminal without installing anything, set two environment variables. Use `ANTHROPIC_AUTH_TOKEN`, not `ANTHROPIC_API_KEY`: the latter makes Claude Code ask you to approve a custom key, which fails in scripts and CI.

export ANTHROPIC_BASE_URL=https://api.lyceum.technology/anthropic
export ANTHROPIC_AUTH_TOKEN=lk_<your_api_key>
export ANTHROPIC_MODEL=z-ai/glm-5.2
claude

Inside a session, `/model` followed by a model ID switches models on your next message, without a restart. Take model IDs from our models page, not from a fixed list.

Check where custom-model support stops

Cursor sends only its Ask and chat panel to a custom model, and it needs a paid Cursor plan to do so. Its agent, other editing modes, Tab completion and cloud agents stay on Cursor's models. Our example team needs chat, agent edits and completion. Chat reaches the model, agent edits and completion do not, so Cursor scores 1 of 3. For a full agent workflow, our Cursor page points to Claude Code.

Copilot reaches further. In VS Code you enter your own server address and key. Chat, commit messages and title generation then use your model. Agent mode works too, once you switch on an experimental setting. Inline completion stays on Copilot's models, and semantic search needs a Copilot plan. Chat and agent edits reach the model and completion does not, so Copilot scores 2 of 3.

Copilot has two quirks that we describe on our Copilot page. It rejects a slash in model names, so write `z-ai-glm-5.2` instead of `z-ai/glm-5.2`. And GLM 5.2 thinks before it answers, which Copilot cannot switch off. Copilot also caps the length of the reply. The thinking can then use up the whole limit, and the reply arrives empty. Use the variant with thinking switched off, which we name `z-ai-glm-5.2-instant`.

Claude Code has no features left on another model, so we do not score it. Its limit is vendor support. Anthropic's documentation says it does not support routing Claude Code to non-Claude models through any gateway. A gateway is a proxy between the tool and the model provider. The same page says a gateway that does not forward new Claude Code capabilities breaks the matching features. Claude Code can connect to our endpoint, but its vendor does not back that setup. Every Claude Code update needs a retest.

Codex runs on Lyceum through our OpenAI-compatible endpoint. OpenAI documents how to point Codex at a custom model provider by setting a base URL and authentication. Set the provider's `base_url` to `https://api.lyceum.technology/openai/v1`, read the API key from an environment variable and use `wire_api = "responses"`. Our endpoint accepts only function tools, so switch off Codex's built-in web search and optional integrations such as plugins and MCP servers; otherwise requests fail with an unsupported tool type error. Recent Codex versions expect a named profile in its own file, for example `~/.codex/lyceum.config.toml`, rather than a `[profiles.lyceum]` table in the main config. Then start Codex with `codex --profile lyceum`.

Test an edit through the complete agent loop

A passing chat is a weak test. The agent loop is where tools fail, because every turn depends on the model returning a well-formed tool call. Test one real edit from start to finish.

Check six things: multi-file edits, tool calls, streaming (text arriving as it is generated), reasoning output, permission prompts and recovery after a failed command. Our guide to verifying function calling before switching shows how to test the tool-calling part.

Now size the test. Assume one hypothetical edit takes 12 turns. Each turn resends the files and the conversation so far, so assume 30,000 input tokens and 800 output tokens per turn. Our listed GLM-5.2 prices on 20 October 2026 are $1.50 per 1M input tokens and $4.50 per 1M output tokens. The calculation is:

input  = 12 turns x 30,000 tokens = 360,000 tokens = 0.36M tokens
output = 12 turns x    800 tokens =   9,600 tokens = 0.0096M tokens
cost   = 0.36M x $1.50 + 0.0096M x $4.50 = $0.54 + $0.0432 = $0.5832

That is about $0.58 per edit and $5.83 for ten edits. Cached input, which is repeated prompt text billed at a lower rate, would make it cheaper, so this is an upper bound. The example sizes a pilot's token spend. It does not measure whether the model finishes the edit.

Pilot the configuration before switching the team

Run a pilot before you move everyone. Our pilot guide suggests a named group, for example 5 to 8 people. Fix the repositories and the window first, and write the success criteria before day one.

Use the feature ratio as one criterion. If every needed feature reaches your model, the tool can move once the agent-loop test passes. If one does not, decide whether it can stay on the vendor's model. In our example, neither Cursor nor Copilot reaches 3 of 3, so both need that decision. Retest after each tool update.

Bring your required tool features and pilot results to our engineers.