Codex from Beginner to Expert: A Complete Guide to the All-Purpose AI Agent

From AI Coding Tool to All-Purpose Agent

When people hear about OpenAI's Codex, many think "just another AI coding tool." But that perception is outdated. Codex has evolved into an all-purpose AI agent that can handle all kinds of work—writing code, creating presentations, generating Excel spreadsheets, drafting Word reports, controlling browsers, and even producing videos.

It's fundamentally different from ChatGPT. Here's a renovation analogy: ChatGPT is like a design consultant who only gives advice—you show it a photo of your kitchen, and it says "move the stove 20cm to the left, change the cabinets to cream white." Sounds great, but you still have to move the stove and paint everything yourself. Codex, on the other hand, is the construction crew that actually does the work—it measures, drafts blueprints, moves the stove, paints the walls, and even takes a photo of the finished result for your approval.

More importantly, Codex can directly read and write files on your computer, create and run programs, search the web, control browsers, and after editing code, it can even commit to repositories and deploy. This is why it's called an "Agent"—an AI that can take autonomous action, not just a Q&A chatbot.

Agent is the most fundamental paradigm shift in AI over the past two years. Traditional AI models like ChatGPT in the GPT-3.5 era were "passive responders"—they answered one question at a time with no autonomous action capability. Under the Agent paradigm, AI has a complete closed-loop ability to perceive its environment, formulate plans, invoke tools, and execute actions. This concept originates from the Agent-Environment interaction framework in reinforcement learning, but has been redefined in the era of large language models: the LLM serves as the "brain" for reasoning and decision-making, while external tools (file systems, browsers, terminals, APIs) serve as the "limbs" for executing actions. Major Agent frameworks in the industry today include OpenAI's Codex, Anthropic's Claude Code, and Google's Jules. Their common characteristics are: the ability to decompose complex tasks into multiple steps, self-correct based on feedback during execution, and invoke external tools to complete actual operations.

Codex's Four Versions and Account Preparation

Codex offers four ways to use it: CLI (Command Line Interface), VS Code extension, desktop client, and web version. All four versions have identical performance and mostly overlapping features, but considering overall ease of use, feature completeness, and beginner-friendliness, the desktop client is the top choice.

CLI (Command Line Interface) means interacting with programs by typing text commands in a terminal. It's the most traditional way developers work, with advantages in scriptability and automation, but the barrier for non-technical users is extremely high. VS Code is Microsoft's open-source code editor that commands over 70% of the global developer market share thanks to its rich plugin ecosystem. When Codex exists as a VS Code extension, it integrates directly into developers' existing workflows. The desktop client is a standalone installed application that doesn't depend on a browser or editor and typically has more complete system permissions (like file read/write and screen control), which is why it excels in feature completeness.

Before using Codex, you need a ChatGPT account, preferably with a Plus or Pro subscription. While free accounts can now access it, the quota is extremely limited and runs out after just a few uses. Plus users can send 30 to 150 messages every 5 hours, which is sufficient for normal daily use; heavy users or teams should consider Pro.

It's worth mentioning that compared to similar tools like Claude Code, Codex is more generous with quotas—not only does it give more, but it also "arbitrarily" resets quotas frequently, and account restrictions and bans are much more lenient.

Login Method Comparison

There are two login methods. Logging in with a ChatGPT account is most recommended: message quotas directly use your subscription allocation, you get first access to the strongest models, and all advanced features like cloud tasks are unlocked. Logging in with an API Key has more limitations: slower model updates, no cloud tasks available, and pay-per-use billing (a big task could easily burn through several dollars). Overall, subscribing to Plus and logging in with a ChatGPT account offers the best value.

Core Interface: The Difference Between Projects and Conversations

After entering the main interface, the most important thing to understand is the difference between "Projects" and "Conversations."

Conversations are like chatting with ChatGPT in the desktop app—suitable for miscellaneous work: gathering information, writing copy, translating, answering questions. Projects are much more powerful. Each project corresponds to a folder on your computer, and all files generated within a project (PPT, Excel, Word, code, images) are saved in that folder for unified management.

Remember this simple rule: Whenever file generation is involved, work within a project; if you're just chatting casually, use a conversation. A project can contain multiple conversations, each handling one task—think of a project as the main folder, and conversations as individual work threads within it.

Three Permission Modes Explained

Because Codex can directly modify files on your computer and run commands, there's a concept of "delegation" with three modes:

• Default Permissions: The safest option. Codex can only modify files within the current project folder, and any internet access, terminal command execution, or external file access requires your approval. Ideal for beginners.
• Auto-review: Codex self-assesses risk. Safe operations (like creating new files) pass automatically, while risky operations (like deleting files) trigger a confirmation dialog. It's like having an internal approver.
• Full Access: Maximum permissions—Codex can do anything without asking. Most efficient but carries risk. Suitable for users already familiar with Codex's behavior and who have project backups.

Beginners should use default permissions for the first week, then consider switching to full access once comfortable and with Git backups in place. Git is a distributed version control system developed by Linux creator Linus Torvalds in 2005, and is now standard for virtually all software projects. Its core value lies in: recording every modification history of files, supporting parallel development by multiple people without conflicts, and allowing rollback to any historical version at any time. When Codex breaks a file, users can roll back to the last correct committed state with a single command—this is why the article repeatedly suggests "commit often"—the more frequent the commits, the finer the rollback granularity, and the smaller the loss.

Model and Thinking Intensity Selection

In the bottom-right corner of the input box, you can switch models and thinking intensity. For models, GPT-5.5 is currently the strongest and recommended as the default; 5.4 covers the vast majority of scenarios; 5.4 mini is smaller and faster, suitable for simple tasks to save quota; 5.3 Codex is a veteran model specifically optimized for programming.

Thinking intensity comes in four levels: low, medium, high, and ultra-high. Low barely thinks—fastest but error-prone; medium is the recommended daily balance; high is suitable for moderately complex tasks; ultra-high is the slowest but smartest, ideal for stubborn bugs or large-scale refactoring that you can't solve otherwise.

Thinking intensity corresponds to the AI model's reasoning depth, technically called Chain-of-Thought reasoning. After OpenAI released the o1 model in 2024, "letting AI think longer for better answers" became industry consensus. The principle is: before outputting a final answer, the model generates an internal reasoning process (similar to a human's scratch paper). The more reasoning steps and verification, the more accurate the result—but computational resources (tokens) consumed also increase proportionally. At low thinking intensity, the model outputs answers almost directly (like human intuition); at ultra-high intensity, the model repeatedly verifies and considers edge cases (like human deep thinking). This explains why ultra-high intensity is slowest but smartest—it spends several times longer working things out on its "scratch paper."

Practical Workflow: Review, Edit, and Commit

There are two ways to create a project—create a blank project (start from scratch) or use an existing folder (work with existing code or files).

After issuing instructions, Codex displays its complete thought process: what files it's analyzing, what it plans to do, and why. When it generates web pages, Word documents, PPT, or Excel files, you can click the filename to preview directly.

The most practical feature here is annotations: after enabling it in the top-right corner of the preview interface, you can select unsatisfactory areas and type your feedback. Codex can then make precise modifications to details—much more efficient than trying to describe positions in text.

After modifications are complete, clicking the review button in the top-right corner expands the diff panel—green indicates additions, red indicates deletions, and every changed line is clearly visible. The diff panel is a core tool for code review, originating from the Unix diff command. It compares file content before and after modifications line by line, using color coding to intuitively display changes. In professional development workflows, code must go through Diff review (Code Review) before merging, ensuring every change is reasonable and doesn't introduce bugs. Codex brings this professional workflow to ordinary users—even if you don't write code, when Codex modifies your Word document or PPT, you can see exactly what it changed through the diff panel. If satisfied, you can commit (if the project uses Git); if not, you can undo with one click.

Queuing, Priority Insertion, and Parallel Operations

These three are frequently used daily operations:

• Queuing: While Codex is working on task A, you can send task B directly, and it will queue behind A for sequential execution.
• Priority Insertion: Click the guide button next to the message to immediately inject new requirements into the currently executing task (e.g., suddenly wanting to switch to iOS-style UI while building a website).
• Parallel: Open a new conversation to run multiple tasks simultaneously without interference—you can even run tasks in parallel across projects. Note that memory isn't shared between conversations, but all can access files in the same project folder.

Skills and Plugins: Extending Codex's Capabilities

Many people confuse "Skills" and "Plugins," but the difference is actually simple.

Skills are pre-written execution steps that package the fixed workflow, considerations, and resources for completing a specific task into a Markdown file. For example, an image generation workflow of "define description → choose style → call model → output" is a skill. The most commonly used built-in skill is imagegen (image generation). Markdown is a lightweight markup language that uses concise plain-text syntax to express formatted content (e.g., # for headings, * for bold, - for lists). AI models encountered massive amounts of Markdown text during training, so they have excellent comprehension and generation capabilities for this format. Additionally, Markdown's structural characteristics (heading hierarchy, lists, code blocks) make it easy for AI to parse instruction priority and logical relationships, which is why skill files and configuration files use this format.

Plugins are one level above skills. A plugin typically contains multiple skills plus connectivity to external applications. For example, the computer use plugin can take over your computer and internally includes multiple skills like app operation, screen recording, and keyboard control. Computer Use is an AI capability first publicly demonstrated by Anthropic in 2024. Its principle is that AI "sees" the current interface by capturing screenshots, then controls the computer by simulating mouse clicks and keyboard inputs—essentially mimicking how humans use computers. The advantage is extreme versatility—any application with a graphical interface can be operated without dedicated API integration; the disadvantage is slower speed (requiring repeated screenshot-analyze-operate cycles) and occasional misjudgment of interface elements.

How to trigger: type @ to invoke plugins, type $ to trigger skills, and you can use both in the same message.

Office Scenario Application Examples

With the plugin ecosystem, Codex can handle a large volume of daily office work:

• Word documents: Use the document plugin to automatically search the web for information and generate reports with tables of contents and tables;
• Excel spreadsheets: Use the spreadsheets plugin to generate data tables with color-coded annotations;
• PowerPoint presentations: Use the presentation plugin to generate business-style slide decks.

You can even request Word, Excel, PPT, and a cover image all in a single message—four files done at once. (Some plugins currently only support Mac; Windows users may not find them.)

Advanced Features and Best Practices

Automated Scheduled Tasks

You can create scheduled tasks using natural language, such as "every morning at 9 AM, automatically search for AI stock information and generate a report." However, it's recommended to test-run it in a regular conversation first to confirm the results meet expectations before setting it as a scheduled task—otherwise you'll waste quota for nothing.

Workspace and Cloud Modes

Local mode directly modifies real files (suitable for small changes, but develop a backup habit); Workspace mode creates parallel copies in the background, letting multiple AIs work without interfering with each other, and you decide whether to merge or discard after review; Cloud mode sends tasks to a server for execution, ideal for time-consuming large tasks. The underlying principle of Workspace mode is similar to Git's Branch concept—each workspace is like an independent timeline where all changes don't affect the main line. Only after you confirm satisfaction do you merge them back. This mechanism ensures that even if the AI makes mistakes, your official files won't be contaminated.

The Power of the Built-in Terminal

Press Ctrl+J to open the terminal. It automatically follows the working directory of the current conversation, and Codex can read terminal output (like checking if the server is reporting errors). Here's a practical tip: if you also have Claude Code installed, you can launch it directly from the terminal, leveraging two AIs for their respective strengths—Codex excels at browser control and image generation, while Claude Code excels at frontend design optimization.

The AGENTS.md Configuration File

Create this file in your project's root directory, and Codex will automatically read it on every startup, treating its rules as work guidelines. It solves the problem of new conversations having no memory—like writing an onboarding manual for a new colleague. Keep it under 150 lines; writing too much actually takes up AI memory capacity.

This involves an important technical limitation: the Context Window. The amount of information an AI model can "remember" in a single conversation has an upper limit (measured in tokens, with current mainstream models ranging from 120K to 2 million tokens). AGENTS.md content occupies part of the context window at the start of each conversation. If it's too long, less space remains for actual work content, and the AI may "forget" earlier information from the conversation. Therefore, 150 lines is a practice-verified sweet spot—covering key rules without excessively squeezing working memory.

Six Codex Usage Principles

1. Use projects for anything involving files, not conversations;
2. One task per conversation—the purer the conversation, the better the AI performs;
3. For complex tasks, have it draft a plan first—use planning mode to confirm before execution;
4. Clearly define "what done looks like"—provide verifiable completion criteria;
5. Commit frequently to easily roll back to correct states;
6. Have Codex review Codex's code—open a new conversation to review previous changes, which often catches overlooked issues.

The principle behind #6 is worth elaborating: it's essentially the AI version of the "Four-Eyes Principle" from software engineering. In human development teams, the code author and reviewer must be different people because authors tend to develop mental blind spots about their own logic and miss vulnerabilities. Similarly, opening a new conversation is like bringing in a fresh AI reviewer with no preconceptions—it doesn't know the previous conversation's reasoning path, making it easier to spot problems from a bystander's perspective. This is also why "the purer the conversation, the better the AI performs"—too much mixed context causes the AI to get stuck in existing thought patterns and lose objectivity.

Final Thoughts

Codex has evolved from a pure coding tool into an all-purpose assistant that uses AI to accomplish all kinds of work. Whether you're in operations, photography, or content creation, you can integrate it into your workflow for efficiency gains—you don't need to know HTML, CSS, or JavaScript; you just need to clearly describe your requirements in plain language.

But it's important to emphasize: how powerful Codex can be ultimately depends on you. The better you understand your project and the more clearly you can describe your requirements, the higher quality its output will be. Vague requirements only produce vague results. This is a universal truth for all AI tools: good input produces good output. In the AI field, there's a dedicated term for this called "Prompt Engineering"—how to organize language, provide context, and set constraints to maximize AI output alignment with expectations. It's essentially a new form of human-machine communication skill that may become a foundational literacy for every knowledge worker in the future.