OpenAI Just Dropped GPT-4.1 (Yes, After 4.5)

Big news: OpenAI just dropped a new family of models called GPT-4.1.

Yes, you read that right, they released 4.1 AFTER 4.5. I think they might be taking the "never let them know your next move" meme a bit too far.

Sam Altman, CEO of OpenAI acknowledges that their naming needs some work with a post on X-twitter:

So, if you’re looking to make fun of OpenAI for their funny model naming convention (or lack thereof), this is your last chance.

Good news is, the name is the least interesting part of this announcement.

I watched the livestream event and spent a few hours testing the new models. Candidly, I am very, very excited about this release.

In today's newsletter, I'll break down:

• The three new models and what makes each one special

• The massive 1M token context window and what it enables

• Why these improvements matter for developers and agent builders

• How you can start using GPT-4.1 today (even without API access)

Let’s get right into it!

—@dharmesh

The Three-Tier Approach: Something for Everyone

First off, OpenAI has done something really smart with this release - they've created a family of three distinct models:

• GPT-4.1: The flagship model with full capabilities

• GPT-4.1 mini: A more efficient middle option

• GPT-4.1 nano: The lightning-fast, budget-friendly version

This tiered approach is exactly what developers have been asking for. Different applications have wildly different needs, and now we can choose the right tool for the job instead of always paying premium prices for capabilities we might not need.

Of the bunch, the nano version particularly caught my attention.

It's OpenAI's fastest model ever with extremely low latency and pricing that's almost hard to believe - just $0.10/million input tokens and $0.40/million output tokens.

Here's the full pricing breakdown:

• GPT-4.1: $2 per million input tokens and $8 per million output tokens

• GPT-4.1 mini: $0.40/million input tokens and $1.60/million output tokens

• GPT-4.1 nano: $0.10/million input tokens and $0.40/million output tokens

While nano sacrifices some accuracy compared to the full model, it's still remarkably capable for many everyday tasks. For applications where you need to process thousands of items or provide near-instant responses, it's a complete game-changer.

I’ll get into how to access 4.1 later below (so bear with me for now as I nerd out for a bit).

The Million-Token Context Window

One of the most exciting features of all three GPT-4.1 models is the 1-million-token context window. This opens up a whole new world of what’s possible.

To put this in perspective, a million tokens represents roughly 750,000 words of text. That's enough to process the entire text of most books with room to spare!

Here's just a couple reasons for why this matters for builders:

• Entire codebases: You can now analyze complete repositories in a single prompt

• Complete documentation: Feed in your entire API docs, user manuals, or technical specifications as context

• Long-form content: Process entire books, legal documents, or research papers without chopping them up

This creates fascinating possibilities we couldn't consider before. Imagine building an agent on agent.ai that can analyze your entire product documentation, codebase, AND customer support history at once to identify potential improvements.

While other providers like Google (with Gemini 2.5 Pro) have offered million-token windows, OpenAI's implementation has been particularly solid in my testing. It feels like the models have much better vibes now (more on that below).

One important note: OpenAI's internal testing shows accuracy does drop from 84% with 8,000 tokens to about 50% with the full 1 million tokens.

Still, having the option to process this much information at once opens up entirely new categories of applications. But it’s worth keeping in mind.

Doubling Down on What Matters

Instead of fancy bells and whistles, OpenAI worked on the things that really, really matter (at least to me): coding use cases, instruction following and large context window.

This means that many applications (like HubSpot and agent.ai) will get immediate benefit.

After several hours of testing, here's what impressed me most:

• Better code generation: The code/app generation capabilities have much better vibes now. What was suggested was that applications generated with 4.1 are more aesthetically pleasing with better UI. This could not come at a better time.

• More reliable instruction following: The model adheres to response structures and formats much more consistently, which is critical for building reliable systems.

• Improved language support: Python is still the de-facto preferred language, but 4.1 has improved support for other languages. I'm a Python person through-and-through, but good for whoever is working in those other languages.

Overall, this is a really solid set of models from my favorite frontier model provider. It keeps pushing us forward along the dimensions that matter a lot to a lot of companies. It's faster, cheaper and smarter. Better code gen. Better instruction following. Much larger context window.

For builders focused on practical applications rather than benchmark scores, this release delivers exactly what we need.

Try It Today (And My Final Thoughts)

If you're eager to test out GPT-4.1 today, I've got you covered with a few options:

For developers:

• All three models are already available through OpenAI's API

• All three models are also available on agent.ai to build into your agents

For non-developers:

• The most direct way to try these models is through our GPT-4.1 agent - completely free, no coding required

• While not yet available in ChatGPT, you can also experiment in OpenAI's Playground if you have developer access

To wrap things up: this is one of those releases that might not sound revolutionary by name, but delivers substantial improvements where they matter most.

The focus on practical improvements rather than flashy demos shows that OpenAI is listening to what developers need. It's faster, cheaper, and smarter - with better code generation, more reliable instruction following, and that game-changing context window.

Now if you'll excuse me, I'm off to go write some code...

—Dharmesh (@dharmesh)