Beginner's Guide to Codex: Connect DeepSeek Without a ChatGPT Subscription

Why Everyone Is Starting to Use Codex

Codex has been gaining popularity fast, and many people are making it their go-to AI tool for daily work. The biggest difference between Codex and familiar chat tools like ChatGPT is this: chat tools are just a language model — you ask, it answers, and that's the end of it. Codex, on the other hand, is an AI Agent — beyond the "brain," it comes equipped with a set of tools that can actually get things done.

This means Codex can break down tasks on its own, call tools to execute them, self-correct when things go wrong, and see a task through from start to finish. Its capabilities span two major areas: it's a powerful AI coding tool that can build websites, apps, and mini-programs; it's also a productivity partner that can directly read and manipulate files on your local computer — making spreadsheets, creating presentations, or drafting reports from your own materials.

Compared to another popular agent, Claude Code, Codex is more beginner-friendly and less prone to account bans. But there's one barrier — the official requirement to subscribe to ChatGPT Plus ($20/month), plus the challenge of dealing with network access issues. That's exactly what this guide is here to solve: how to connect the domestic model DeepSeek to Codex, getting a nearly identical experience at minimal cost.

Installation: Download Codex and Connect DeepSeek

Step 1: Download Codex

The official download page is openai.com/codex, which automatically detects your operating system (Windows or macOS). Note that starting from a certain version, OpenAI merged Codex into ChatGPT, so what you're actually downloading is the ChatGPT desktop app. After installation, the window opens automatically and asks you to log in.

Two official login options are available: use a ChatGPT account with an active Plus/Pro subscription (which includes Codex credits), or use an OpenAI API Key for pay-as-you-go billing. If you have neither, you'll need to connect a third-party model instead.

Step 2: Switch Models Using CC Switch

Swapping the GPT model powering Codex for a different one is essentially a matter of editing a configuration file — telling Codex to stop connecting to OpenAI's servers and instead point to a different model's endpoint and API key. Doing this manually is error-prone, so the recommended tool is CC Switch, a graphical utility available at ccswitch.io.

The value of CC Switch is that it turns the tedious process of locating and editing config files into a simple point-and-click interface. More importantly, its top navigation bar lets you manage model configurations for multiple AI tools simultaneously — Codex, Claude Code, Gemini, and more — connecting them to DeepSeek, Kimi, MiniMax, and other domestic models all in one place. Switching back to the official model is just a single click away.

Step 3: Add DeepSeek as a Provider

After opening CC Switch, confirm that the top bar is switched to Codex (the default on first launch might be Claude Code — make sure you select the right one). Click the plus button on the right to add a new provider and select DeepSeek. The provider name, website URL, and API endpoint will all be filled in automatically. All you need to provide is your own DeepSeek API Key.

Getting a key is straightforward: register and log in at the DeepSeek open platform, top up around 10 RMB (which should last a long time), and create a key starting with sk under "API Keys." Important: this key is only shown in full once, so copy and save it immediately.

The Critical Step: Enable Local Routing

If you try to activate the provider without enabling routing first, you'll get a prompt to turn on the router. Here's why: Codex communicates with OpenAI models using a specific API format, while DeepSeek, Kimi, and other domestic models use a more generic but slightly different format — they don't speak the same "dialect." CC Switch's local router acts as a translator in the middle, converting what Codex sends into a format DeepSeek understands, and converting the response back.

Go to Settings → Routing → Local Routing, enable both "Show toggle on homepage" and "Master routing switch," then turn on the Codex switch in the routing enable section. Once configured, fully quit and restart Codex (just closing the window may leave it running in the background), or the new configuration won't take effect.

After restarting, you can chat normally. At this point, you haven't logged into any OpenAI account, yet Codex responds perfectly — proof that it's successfully connected to DeepSeek. (One side note: if you ask it "what model are you?", the answer may not be accurate, because Codex's system prompt includes something like "you are GPT-5" — this is expected behavior.)

The local router is essentially a lightweight proxy server running on your computer. Codex, as the client, only understands OpenAI's API interface specification (the OpenAI API format). While DeepSeek, Kimi, and other domestic models also expose public APIs, there are subtle differences in parameter names and response structures. When CC Switch starts the local router, it listens on a local port (typically a localhost port). All of Codex's requests are sent there first; the router converts the format and forwards the request to DeepSeek's servers. DeepSeek's response is then translated back into the OpenAI format before being returned to Codex. This entire process is completely transparent to Codex — it thinks it's been talking to OpenAI the whole time. This also explains why asking "what model are you?" might yield an incorrect answer: the system prompt still says GPT, and Codex has no idea the underlying model has been swapped out.

Basics: Getting to Know the Interface and Your First Project

Interface Layout

Codex's interface is clean and simple: the left side has a menu bar (search, new task, scheduled tasks, plugins, etc.), and the right side is the conversation area. The search function doesn't just search titles — it also searches conversation content. For example, if you want to find a quote sheet you asked it to write earlier, just search "quote."

The most important concept is the Project. In Codex, a project is essentially a folder on your computer. If you're working on a personal website and a management system at the same time, you can create two separate projects to keep them independent. The key value of a project is this: no matter which conversation you're in, Codex can directly access all the files in that folder — no need to re-upload or re-explain anything each time. This is a fundamentally different experience from using a regular chat tool.

Building a Habit Tracker from Scratch

Let's walk through a "habit tracker" mini-tool as an example. The first step is to create a new project (which is equivalent to creating a new folder). Once a project is selected, a few status indicators appear below the input box: the project name (linked to a folder), local mode (working on your machine), and Git branch (if Git is installed, it'll show the Main branch — this is the "undo history" mechanism for code version control).

Before starting, it's a good idea to enable Plan Mode — instead of diving straight into writing code, Codex will first break the task into a detailed plan in Chinese for you to review. You can adjust the direction as many times as you like, and only when you're satisfied do you click "Execute Plan" to proceed. This helps prevent it from going off track from the very beginning.

During execution, Codex will frequently pop up dialogs asking for your approval (e.g., "Allow starting a local web server?" or "Allow access to localhost:8000?"). This is the core difference from ordinary AI: after writing the code, it opens a browser on its own and tests all the features itself, ensuring the code it delivers has been actually verified. You didn't write a single line of code, yet a working website was built, tested, and placed right in front of you. That's the magic of Vibe Coding.

Permissions and Styling

Permission settings have three levels: Default (asks at every step — most cautious but interrupts the flow), Auto Review (an AI reviewer checks on your behalf — recommended for beginners), and Full Access (fully automated — most efficient but least hands-on control).

When it comes to styling the page, instead of vague descriptors like "minimalist" or "high-end feel," just upload a reference image. Use the plus menu to "Add photos and files," share a style reference, and let Codex match the color scheme and visual style — the results are far more precise.

Intermediate: Core Features That Double Your Efficiency

Steering, Preview Focus, and Context Management

The Steering feature lets you intervene at any point while Codex is working. If you notice it's heading in the wrong direction, click the steer button to inject new instructions into the current task — no need to wait for it to finish before course-correcting.

Preview Focus solves the problem of "words can't accurately describe position." You can directly click on an element in the right-side preview to tell Codex how to change it there, or visually adjust colors, font sizes, spacing, and other details with real-time preview. For any visual adjustments involving specific locations, this feature is both fast and accurate.

Context is Codex's memory, but it has a capacity limit. Codex has a smart compression mechanism that condenses long conversations into key summaries to free up space, and it usually does this automatically. You can also manually type the slash command /compress — in testing, this can drop context usage from 92% down to 3% instantly.

Branching, Skills, and Plugins

Branching lets you copy the current conversation from a specific point and spin off a new thread to explore a different question (e.g., "how would I add a login feature later?") without disrupting the main conversation.

Skills are a mechanism that's been trending heavily over the past couple of years — think of them as a "professional playbook" written for the AI. A Skill consists of a Skill.md file (containing a self-description and specific rules), and can be paired with scripts, templates, and reference materials. The key advantage is on-demand loading — Codex only reads the brief self-description to decide whether to invoke a Skill, and only loads the full content when it's actually needed. This means you can safely install multiple Skills without filling up your context. The article demonstrates using the built-in Skill Installer to install the "Front End Design" skill with one click, giving page designs a distinctive look that breaks free from the generic AI aesthetic.

Plugins are essentially Codex's app marketplace, containing Skills, application integrations (like Figma and GitHub), and MCPs (the standard protocol for AI to connect with external tools). The article shows how using the Netlify plugin, a single sentence deploys a local habit tracker as a publicly accessible URL — transforming Codex from a "local assistant" into an "assistant that can connect to the outside world and actually ship things."

MCP (Model Context Protocol) is an open standard proposed by Anthropic in late 2024 and adopted across the industry. Its purpose is to let AI models connect to various external tools and data sources in a unified way — similar to how USB ports work for hardware peripherals. Before MCP, every AI product that wanted to integrate with GitHub, Figma, databases, or other third-party services had to build custom plugins from scratch, making maintenance extremely costly. MCP defines a standardized "tool description + invocation + response" protocol. A third-party service only needs to implement an MCP server once, and every AI client that supports MCP — including Codex, Claude Code, and others — can call it directly. For regular users, MCP means the capability boundary of AI assistants can continuously expand: community developers keep releasing new MCP plugins, and once installed, those capabilities are immediately available — without waiting for Codex to officially support each integration one by one.

Advanced: From Tool to Long-Term Partner

Personalized Instructions

To have Codex remember your preferences without repeating yourself every time, use Personalized Instructions, which operate at two levels: global rules (stored in agents.md, applying across all projects — e.g., "always communicate in Chinese") and project rules (placed in the project folder's agents.md, applying only to that project). You can simply ask the AI to write these rules in for you. Note that these rules are essentially prompts — reminders, not hard constraints. They significantly reduce repetition, but may occasionally be overlooked during very long tasks.

Custom Skills, Scheduled Tasks, and Computer Use

With the built-in Skill Creator, you can crystallize tasks you repeatedly do in your own particular way into a personal Skill (e.g., "remove the AI-sounding tone from copy") — no need to manually create files or remember formatting rules.

Scheduled Tasks shift Codex from reactive to proactive — you can set it to collect and summarize AI news every morning at 9 AM. The article specifically highlights three precautions: stick to low-risk collection and organization tasks; run it manually once first to verify it works correctly; and note that Codex must be running for scheduled tasks to execute.

The most futuristic feature is Computer Use — it can take direct control of your computer, moving the mouse, clicking buttons, typing, and switching windows just like a real person. The article walks through a full demo of having it automatically open a browser, research new AI products, and compile them into a list. But it has two notable drawbacks: it burns through credits extremely fast (every step requires a screenshot to understand and reason about the screen, potentially consuming dozens of times more tokens than a normal conversation), and you need to watch it the whole time (its actions happen directly on your real computer, so mistakes have real consequences). It represents the future form of AI assistants, but for now it's better suited for careful, small-scale experimentation.

The technical principle behind Computer Use is having the large model process screen screenshots as input and output operation sequences like mouse coordinates and keyboard commands. Every step requires capturing the current screen, understanding the interface state, and planning the next action — meaning that a seemingly simple task like "open a webpage and copy its content" may involve dozens of visual reasoning steps and tool calls, consuming an enormous amount of tokens. This is the fundamental reason why the feature burns through credits so fast. Furthermore, since actions are applied directly to the real system — unlike code execution in a sandboxed environment — if the AI misidentifies a UI element (e.g., clicks the wrong button or submits an incorrect form), the consequences take effect in reality immediately, and some actions may be irreversible. When using Computer Use, it's recommended to close unrelated applications beforehand, avoid touching the keyboard or mouse during operation, and be especially cautious with tasks involving important data.

Wrapping Up

From installing Codex and connecting DeepSeek, to mastering projects, plan mode, steering, Skills, and plugins, to personalized instructions and automation capabilities — this guide has provided a complete walkthrough of Codex's potential as a next-generation AI Agent. It's beginner-friendly, less prone to account bans, and pairing it with a domestic model dramatically lowers the cost of use. For everyday users who want to experience AI Agent capabilities with minimal friction, Codex + DeepSeek is undoubtedly one of the most cost-effective combinations available right now.