Codex: from developer tool to work agent

In Brief

Codex started as a coding assistant. Today more than four million people use it weekly, and most of the tasks are no longer about writing code. Codex builds reports, analyzes spreadsheets, organizes files and continues your projects from your phone. The tool uses code, but the result doesn't have to be code.

The shift is easy to describe, harder to get used to:

You no longer do everything yourself. You lead the work.

Podcast

What Codex actually is

Codex is OpenAI's AI agent for work that needs more than just an answer.

An AI agent here means a system that can take a goal, use tools, read relevant information, take actions and report back. If ChatGPT is a good conversation, Codex is more like a small work process.

OpenAI describes Codex as an agent that helps you build and ship work with AI. It can understand codebases, write and edit code, debug, review changes and automate developer tasks. But the latest OpenAI pages show it can also build documents, work with spreadsheets, make presentations, connect to apps, use the browser, read files and organize work.

The important shift is this:

Codex uses code as a tool, but the result doesn't have to be code.

Just as a calculator uses math without requiring you to be a mathematician, Codex can use code, files and tools without requiring you to be a programmer.

Why Codex started with programmers

Programming was a natural first area because code is concrete. There are files, tests, errors, rules and goals. An agent can read the code, make changes and show exactly what was changed.

In the OpenAI Forum talk Thibault Sottiaux explains that Codex first focused on helping developers. An early public version, called Codex Web, could look at a code project, find the right changes and open a pull request (a request to merge a change) on GitHub. But this got cumbersome because people had to recreate their local setup inside OpenAI's cloud environment.

So the direction shifted: Codex had to work where people actually work, on their own machine, in their own files, in their own projects and eventually across multiple surfaces.

OpenAI now describes Codex as an agent you can use in app, terminal, code editor and on mobile, tied together through your ChatGPT account.

The big shift: from coding help to work help

The most interesting point in the Forum talk is not that Codex can code. It is that even programmers don't just code.

Thibault says software developers maybe spend 20–30 percent of their time on actual coding. The rest goes to reading tickets, prioritizing, discussing solutions, understanding systems, investigating bugs, gathering information and coordinating work. He also says technical users were already using Codex for daily work beyond pure coding, and that the majority of tasks in Codex are now non-coding tasks.

That is an important point for everyone, not just technologists.

A lot of modern work boils down to this:

1. Find the right information.
2. Understand what it means.
3. Gather it into something useful.
4. Make a proposal.
5. Share it with others.
6. Follow up on what's missing.

This applies to a teacher planning a lesson, a founder writing a sales report, a designer collecting feedback, a finance employee comparing numbers, or a 14-year-old organizing a school project.

Codex becomes useful when the work is more than "give me an answer." It becomes useful when the task has several steps.

The practical core: fetch, understand, do, show

In the Forum talk a concrete example from OpenAI is described: a product lead used several small Codex agents to track status before a launch. The agents gathered feedback, followed up with people, updated documents and kept the plan tidy while the product lead could stay in meetings.

This matters because it shows the new way of working:

You don't do everything yourself. You lead the work.

A good leader doesn't just say "fix this." A good leader explains the goal, gives context, sets limits and checks the result. That's how you should use Codex too.

Visual overview: how Codex work flows

What Codex can be used for beyond programming

OpenAI's official use cases page shows Codex can be used for many kinds of work. Examples include analyzing datasets, building reports, cleaning up messy data, building presentations, prioritizing messages, writing product requirements, doing budget reviews, drafting decision memos and using the computer to test apps.

Here are some practical examples:

Building a research overview

You can ask Codex to gather information from documents, notes and open sources, and produce a structured memo.

Example: "Make an overview of arguments for and against this solution. Separate facts, assumptions and open questions."

This suits students, researchers, journalists and managers.

Analyzing spreadsheets

Codex can help read tables, find patterns, build summaries and suggest visualizations.

Example: "Look at the sales data for the last three months. Find which products are growing the most, and explain it in plain language a non-economist will understand."

Useful for small businesses, finance, operations, marketing and project work.

Building presentations

Codex can help you build a presentation structure, suggest slides, pull out key points and write a clear script.

In the Forum talk Thibault says a good task should describe what "done" means. He gives an example with a 10-slide presentation: first the intro, then the main content, and finally open questions and Q&A.

Organizing files

Codex can tidy files, build folders, find duplicates and bring structure.

Example: "Sort these photos by project, date and type. Write a short report of what you moved."

Very relevant for creative people, photographers, content creators and anyone with a chaotic downloads folder.

Building personal software

In the talk Thibault shows an example where he asks Codex to find good bread in San Francisco, build a spreadsheet with prices and descriptions, and then create a website with a map. The point isn't bread. The point is that an ordinary person can build a small personal tool for a concrete need.

They call this "personal software" — small, tailored tools for your own life.

Why this is bigger than efficiency

Many descriptions of AI focus on "something that took days now takes hours." That's true, but a bit too simple.

The real point is this:

Some tasks would never have been done at all.

Not because they were impossible, but because they were too small, too boring or too time-consuming to prioritize.

In the Forum talk Thibault says Codex makes it possible to get small reports, fetch information and build personal tools he otherwise wouldn't have had time for. He describes it as letting the small manual things move out of the way so he can spend his attention on what he actually wants to think about.

A simple analogy:

Before, many good ideas sat in a drawer. Codex isn't the idea. Codex is the hand that helps you open the drawer, sort the contents and make a first version.

Codex on mobile and from anywhere

On May 14, 2026 OpenAI published an update about working with Codex from anywhere. It says Codex is coming to the ChatGPT mobile app, and that users can follow up on work, approve the next step, change direction and add ideas from their phone. OpenAI also states that more than four million people use Codex weekly.

That doesn't mean the phone does everything by itself. The point is that the phone can connect to the machine or work environment where Codex is already running. It could be a MacBook sitting open at home, a Mac mini at the office, or a server in the cloud. Files, permissions, setup and access stay on the machine, while the phone becomes a control panel — really, a remote control.

Example: you're out for a walk and think of an improvement to a document. Instead of waiting until you're back at your desk, you can send a follow-up to Codex from your phone. Codex can continue the work where the project already lives.

OpenAI also describes Remote SSH (a secure remote connection to another machine) and remote connections as ways to use Codex on external machines or dev environments.

The building blocks of Codex

To understand Codex in 2026, you need a few building blocks. Here they are without heavy technical jargon.

Agent

An agent is a digital helper that can take several steps to reach a goal.

Not just: "Answer the question."

But: "Read these documents, find risks, write a report, and show me what you changed."

Context

Context is background information. It can be files, documents, earlier choices, project rules, goals, preferences or messages.

In the Forum talk Thibault says that more and better context produces better results. He also says some of the context only exists in your head, so you have to write down goals, preferences and experience if the agent is going to use them.

A simple analogy:

Codex without context is like an assistant walking into a meeting without knowing what it's about. Codex with good context is like an assistant who has read the briefing first.

Plugins

Plugins (add-ons that connect a service to Codex) let Codex use external services. OpenAI's plugin documentation describes them as packages that can contain Skills, app integrations and MCP servers. Examples in the docs include Gmail, Google Drive, Google Docs, Google Sheets, Google Slides and Slack.

MCP

MCP stands for Model Context Protocol. It is an open standard for connecting Codex to external tools and systems. Think of it as a standard connector, a bit like USB-C for information and tools.

Skills

Skills (reusable skill packs or instruction bundles) are small packages of instructions, resources and sometimes scripts that teach Codex how to do a specific kind of task in a specific way. For example, a skill that builds reports in a fixed style, cleans up data, or follows a particular internal process.

Automations

Automations are tasks that can run again and again, for example daily, weekly or when something happens. OpenAI describes this as a way to run recurring background work where findings can be sent to your inbox.

Example: "Go through my inbox every morning, find the five most important items, and write a short summary with suggested next steps."

Computer Use

Computer Use means Codex can see and operate graphical apps on the computer — click, type and navigate inside programs. OpenAI describes this as useful for testing apps, using the browser, finding settings or doing tasks in apps that don't have a dedicated integration.

Important note for Europe: OpenAI's documentation says Computer Use is for macOS at launch and not available in the EEA, the UK or Switzerland. Availability has to be checked in your actual account and region.

Memory

Memory means Codex can remember useful preferences and work patterns over time. But OpenAI's documentation says memory is off by default, and not available in the EEA, the UK or Switzerland at launch. Same rule applies: check the actual availability in your own account and region.

Safety and control

An agent that can do things needs limits.

Sandbox and Auto-review

OpenAI uses Sandbox (a fenced work area) as a central safety idea. A sandbox is a controlled space where Codex can work without getting unlimited access to everything. Picture a fence around a workbench. Inside the fence the assistant can work. Outside the fence it has to ask for permission.

This matters because Codex can read, change and run things. Without limits an agent could, in the worst case, make mistakes in the wrong folder, send the wrong information, or change something it shouldn't change.

OpenAI also describes Auto-review (automatic safety review). It's an extra agent that judges whether an action is too risky before it's allowed. Think of it as a referee on the sideline: the main agent tries to do the job, while the control agent says "stop" if the action looks too dangerous.

In the Forum talk this is described the same way: the agent can be restricted to specific parts of the filesystem, given read-only access, or kept from changing and deleting data.

Hooks: control points in the workflow

Hooks (rule-driven control points) are scripts or rules that can run at specific places in the Codex workflow. OpenAI describes Hooks as a way to log activity, scan for API keys, build summaries, run validation, or adjust instructions depending on which folder Codex is working in.

A simple analogy:

If Codex is an assistant, Hooks are the checklist on the wall.

Example: before Codex sends out a result, a Hook can check that it doesn't contain secret keys, that the right tests ran, or that the report follows the desired format.

Access tokens: keys for automated work

Access tokens let trusted automations run Codex with the right workspace identity. OpenAI describes this for Business and Enterprise plans, especially when the workflow needs access to the organization's controls and resources.

This is powerful, but tokens have to be treated as secret keys. If an access token leaks, the wrong person or wrong system can get into things they shouldn't.

A simple analogy:

An access token is like a key card for an office. Useful when the right person uses it, dangerous if it's lost.

How to brief Codex well

OpenAI recommends briefing Codex roughly the way you would brief a new colleague. You need to explain the goal, the context, the constraints and what "done" looks like, according to Codex best practices.

Here is a simple template:

In the Forum talk Thibault says a good trick is to be precise about what "good" looks like. If you want a presentation, you should say how many slides, what the first slides should cover, what the main part should explain, and what the closing should contain.

This isn't just a technical rule. It's ordinary good communication.

Bad instruction: "Make something about the project."

Good instruction: "Make a 10-slide presentation for a non-technical leadership group. Start with the problem, show three possible solutions, compare cost and risk, and close with the recommended next step."

The biggest mistake: delegating your own understanding

An important warning from the Forum talk: people may be tempted to delegate everything, including their own understanding.

Thibault says it's a mistake to use Codex just to get things done without understanding the problem better yourself. He recommends also using Codex to explain, build diagrams and help you learn. Chris Nicholson sums it up well: the one doing the work also does the learning.

This may be the most important pedagogical point.

Codex shouldn't just be a shortcut. It should also be a teacher.

Use Codex to ask:

• "Explain this as if I'm 14."
• "What are the three most important assumptions here?"
• "What could be wrong in this analysis?"
• "Draw a simple diagram showing the connection."
• "Ask me five questions to check whether I've understood."

A simple analogy:

If you let the calculator do everything without understanding the numbers, you get faster but not smarter. If you use the calculator to check and learn, you get both.

What this means for non-technical people

For non-technical people Codex is interesting because it can lower the bar for work that used to require technical help.

There used to be two groups:

1. The person who had the problem.
2. The person who could build the solution.

That created queues, meetings, explanations and waiting. The Forum talk describes a shift where the person who has the problem can increasingly build or shape the solution themselves. That applies to data analysis, design tweaks, reports and personal tools.

It doesn't mean professionals become unnecessary. It means professionals can spend their time on harder things.

A data analyst maybe doesn't have to answer 30 small spreadsheet questions. A designer can test small changes themselves. A manager can get a first draft of a decision before the meeting. A student can get help structuring a project before the teacher reviews the content.

What this means for technical people

For technical people Codex is still a powerful coding tool.

OpenAI's developer page describes Codex as useful for writing code, understanding codebases, debugging, reviewing changes and automating developer tasks. It can also be used across several work surfaces — app, terminal, code editor, cloud environments and mobile.

But the biggest change for technical folks may be that Codex helps with everything around the code:

• understanding systems,
• gathering context,
• investigating bug reports,
• summarizing status,
• writing documentation,
• drafting migration plans,
• following up on tests,
• coordinating work,
• keeping longer tasks moving.

OpenAI's "Codex for (almost) everything" describes exactly this: developers use Codex to understand systems, fetch context, review work, debug, coordinate with teammates and keep longer work moving.

Availability and caveats in 2026

Based on the latest OpenAI sources as of May 17, 2026:

How to start safely and smartly

Start small. Don't hand Codex your whole life on day one.

Pick one concrete workflow. Examples:

Use this rule:

Let Codex read first, propose next, and act last.

It's like letting a new assistant see the room before you ask them to move the furniture.

Codex explained for a 14-year-old

Imagine you have a school project.

ChatGPT can help you understand the topic and write drafts.

Codex can also help you organize your notes, build a plan, find what's missing, build a presentation, build a simple website or tidy up your files.

But you still have to be the boss.

You have to say:

• what the project is about,
• what you already have,
• what the teacher requires,
• what Codex is allowed to change,
• how you know the answer is good enough.

One important rule when you use Codex for school: let it help you understand, not just do.

Ask Codex for a simple explanation of what you find hard. Ask for three check questions you can answer, so you know if you've actually understood. Ask for suggestions on what to double-check before handing it in.

Many adults are worried that AI will make kids dumb. That's true if you let Codex do everything without paying attention. The opposite is true if you use Codex as a teacher in addition to a helper. Then you learn while you work.

Let Codex be your teacher.

Codex isn't a magic wand. It's more like a very fast group-project partner that needs clear rules.

What the talk is really pointing at

The Forum talk "Codex for Everyday Work" points at a bigger idea: AI agents are moving from just giving answers to actually doing the work.

In the closing Chris Nicholson says Codex is useful for developers, but also for knowledge workers who hunt for information, analyze data, visualize insight, prioritize and run complex tasks in the background. He suggests people try one workflow — a research memo, a plan, an onboarding process, a report or a decision memo.

That's a good place to start.

Don't ask first: "What can AI do?"

Ask instead:

"Which small, boring, repetitive or delayed task would be easier if I had a tidy assistant with access to the right information and clear rules?"

Summary

Codex started as a tool for programmers, but OpenAI's latest sources show it is now evolving into a broader AI agent for knowledge work. It can read, understand, plan, edit, analyze, visualize and follow up on work, inside the limits you set. Used right, it can also be your teacher and sparring partner along the way.

The best way to understand Codex is not as "AI that writes code," but as:

a directed work assistant that can use code, files, apps and tools to do concrete tasks.

For technical people that means faster development, better review, more automation and less friction.

For non-technical people it means data analysis, reports, presentations, document structure, planning and personal software become more accessible.

For everyone it means the same ground rule:

You still have to own the goal, understand the result and set the limits.

That is where the real value lies. Codex doesn't make human judgment less important. It makes it more visible.

Glossary

Sources and resources