OpenAI just had a busy week, even by AI standards. In three days it shipped a new model family for developers, two new reasoning models, and an open-source coding agent that lives in your terminal.

If you write code for a living, the models are interesting. The terminal agent is the part I'd pay the most attention to, because it says a lot about where AI coding tools are heading. Here's what was released, what each piece is for, and what I think it means for everyday development.

What was released

• 14 April: the GPT-4.1 family arrived in the API: GPT-4.1, GPT-4.1 mini and GPT-4.1 nano. The headline features are a context window of up to one million tokens and a focus on coding and following instructions precisely.
• 16 April: o3 and o4-mini, OpenAI's newest reasoning models, the kind that "think" through a problem before answering.
• 16 April: Codex CLI, an open-source coding agent that runs in your terminal, launched the same day.

Three different things, aimed at three different jobs. Let's take them one at a time.

GPT-4.1: the model for building with

GPT-4.1 isn't a ChatGPT story. It's an API story, aimed at people building products and tools on top of models.

The two things OpenAI emphasised are the ones developers complain about most. Instruction following matters when your app depends on the model returning exactly the format you asked for, every time, not "mostly JSON with a friendly sentence on top". And coding matters because a huge share of what developers send to these APIs is code.

The one-million-token context window is the eye-catching number. It means you can, in principle, pass in a large chunk of a codebase or a long set of documents in a single request. Two cautions from experience with long contexts in general: more context costs more and responds slower, and "fits in the window" is not the same as "the model pays equal attention to all of it". Sending the relevant files still beats sending everything.

The mini and nano versions matter for real products. Plenty of tasks in an app (classifying a support message, extracting fields, short summaries) don't need the biggest model. Smaller, faster models make those features cheaper to run and quicker to respond.

o3 and o4-mini: the thinkers

Reasoning models spend more time working through a problem before they answer. That makes them slower, and better at things where a quick answer is often a wrong one: tricky debugging, multi-step logic, algorithm design, untangling a gnarly SQL query.

The practical split I use with any provider: a fast model for the high-volume, well-defined tasks, a reasoning model when I'd otherwise have to think hard myself. Not every question deserves a model that thinks for a while, and not every bug can be solved by one that doesn't.

This also continues a race we've watched all year: DeepSeek R1 in January, Claude 3.7 Sonnet with its extended thinking mode in February, Gemini 2.5 Pro in March, and now o3 and o4-mini. Reasoning has gone from a novelty to something every major lab ships.

Codex CLI: the one to watch

Codex CLI is a coding agent you run in your terminal, inside your project. It's open source, so you can read exactly what it does, which I appreciate in a tool that will edit my files.

It joins a category that's filling up fast. Aider has been doing AI pair programming in the terminal for a while, and Anthropic released Claude Code as a research preview in February. Now OpenAI has its own entry.

Why terminal agents are a big deal

There's a real difference between an AI that suggests code and one that works in your project. A chat window sees what you paste into it. A terminal agent can:

• read the files it needs, instead of relying on what you remembered to copy,
• make changes across several files,
• run commands, such as your test suite, and react to the output,
• loop: change, run, read the error, fix, run again.

That loop is the important bit. It's the same loop a developer runs all day. When the agent can run the tests itself, a whole class of "the AI wrote code that doesn't even compile" problems disappears, because it sees the failure before you do.

It also changes your job a little. With a terminal agent, you spend less time typing and more time describing the task well, and reviewing what came back. The skills that matter shift towards writing clear instructions, breaking work into small pieces, and reading diffs carefully.

The caution that comes with it

An agent that runs commands in your terminal has real power over your machine and your repo. A few habits I'd keep with any of these tools, from any company:

• Work on a clean Git branch, so every change is one git diff away from being reviewed or thrown out.
• Keep approval on for anything that runs commands, until you trust the tool on that kind of task.
• Never point it at a folder containing production secrets or credentials it doesn't need.
• Review the diff as if a new colleague wrote it. Because, in a way, one did.

What I'd do this week

If you build on the OpenAI API, try GPT-4.1 or 4.1 mini on one of your existing prompts and compare the output with what you use today. If you're curious about agents, install Codex CLI (it's on GitHub), open a side project, and give it a small, well-defined task with tests. You'll learn more about how these tools behave in an hour than from any announcement.

Have you tried a terminal coding agent yet, whether Codex CLI, Claude Code or Aider? What's the first task you'd trust one with?