GPT 5.6 Deep Dive Review: The Most Capable Model Yet — But Also the Most Confusing to Use?

OpenAI GPT 5.6 Deep Dive: More Powerful Model, Worse Product Experience?

OpenAI's latest GPT 5.6 has been called "the most capable and complete release to date" by many users — with across-the-board model improvements and three new tiers: SOUL, TERRA, and LUNA.

Industry context on model tiering: Tiered model architectures have become a defining trend in AI. Anthropic pioneered the "lightweight–balanced–flagship" three-tier structure with Claude Haiku, Sonnet, and Opus, followed by Google with Gemini Flash, Pro, and Ultra. The core logic is straightforward: different tasks have vastly different requirements for reasoning depth, response speed, and cost — a simple information lookup doesn't need the most powerful model, while complex multi-step planning demands top-tier reasoning. GPT 5.6's SOUL, TERRA, and LUNA naming follows this playbook, using more evocative names to help users make intuitive choices. That said, tiering also creates new cognitive overhead: users must now decide not just what to do, but which tier to use — an added barrier for non-technical users.

But accompanying this leap in capability is a product redesign that's giving users serious headaches. Based on feedback from power users, this update has introduced a number of baffling interaction design choices — with some seasoned users calling it "absurdly difficult to use."

This article breaks down the core UX controversies in GPT 5.6, drawing from real-world usage, and explores the broader industry signal OpenAI is actually sending.

Three Major UX Problems: The Complexity Gets Dumped on the User

The new version underwent a sweeping redesign on both desktop and web. The most jarring change: ChatGPT has been folded into the Codex application ecosystem. Open the new version and you'll be greeted by a prompt saying "GPT is now part of Codex" — a move that caught many longtime users completely off guard.

A brief history of Codex's product evolution: Codex was first released in 2021 as a standalone API — a GPT-3 fine-tune purpose-built for code generation and the engine behind GitHub Copilot. Its positioning was narrow: serving professional developers with code completion and natural language-to-code capabilities. In 2024, OpenAI relaunched Codex as a CLI tool, giving it the ability to autonomously execute code and read/write files in local environments — a leap from "code generation tool" to "code execution Agent." This latest integration with GPT 5.6 represents a third repositioning: from developer tool to general-purpose Agent platform for all knowledge workers. This trajectory closely mirrors Salesforce's shift from CRM to "AI enterprise cloud" and Notion's evolution from note-taking to "AI workspace" — a pattern of vertical tools expanding into general platforms in the AI era.

Confusing Entry Points: Chat vs. Work — What's the Difference?

The new GPT web interface features two entry points at the top: Chat and Work. The division sounds clean — one for conversation, one for task execution. In practice, however, the boundary between the two is deeply unclear.

One user ran a test: in Chat mode, they asked GPT to open a Figma link, create a new page, and draw some icons — and it worked. That means Chat mode can invoke design tools just fine. Conversely, Work mode supports open-ended conversation too. Both interfaces look nearly identical, with similar input boxes, leaving users to wonder every single time: Which one am I supposed to use?

A clash of design philosophies: In human-computer interaction, "exploratory conversation" and "goal-oriented execution" represent two fundamentally different user mental models. The former is open-ended and divergent — users need to revisit context, adjust direction, and think out loud. The latter is structured and efficiency-focused, aimed at getting a defined task done. Good product design should provide differentiated interfaces and feedback for each mode — much like how IDEs and note-taking apps both handle text, yet operate on completely different logic. GPT 5.6's attempt to merge both into a single entry point runs into a classic design challenge: the tension between feature consolidation and scenario differentiation. Microsoft Copilot and Google Workspace's AI integrations have faced similar criticism, suggesting this isn't OpenAI's problem alone — it's a design threshold the entire industry must clear as AI tools become platforms.

Schrödinger's Usage Quota: The More Powerful the Model, the More Invisible the Costs

The second issue is more insidious. Work and Codex now share the same Agentic quota pool. Previously, conversations in ChatGPT didn't draw from Codex's quota — but now, selecting Work in the web interface burns through that quota even if you're just chatting.

Industry context on Agentic quotas and billing models: Traditional SaaS products bill by seat or monthly subscription — simple and transparent. AI Agent billing is a completely different beast. Because Agents draw on LLM inference, code execution, web search, file I/O, and other resources simultaneously, the industry has broadly adopted "token consumption" or "task steps" as the billing unit — what's known as "Agentic quota." The biggest challenge with this model is that users have no reliable way to predict actual consumption before a task runs. OpenAI merging ChatGPT's Work mode with Codex's Agentic quota essentially force-combines two billing systems. The intent may be to simplify account management, but the side effect is that users lose any intuition for how fast they're burning through their allowance. This problem is industry-wide — Anthropic's Claude and Google's Gemini have faced similar complaints about usage transparency in Agent mode.

Worse still, you can't check your full usage directly within the ChatGPT web interface — you have to navigate to the Codex page separately to find your balance and consumption history. The irony is hard to miss: as AI becomes more autonomous, usage visibility should increase, not decrease. Instead, the more capable the model gets, the more invisible its costs become.

Chat Crammed Into a Floating Window: Your Thinking Space Gets Shrunk

The third issue: the chat function has been relocated inside the Codex workspace as a small floating window. For a quick knowledge lookup, this barely matters. But the highest-value use cases are precisely those where you need to dig into a complex problem before assigning a concrete task to Codex — revisiting earlier context, refining your thinking, going back and forth until a plan takes shape.

This kind of "brainstorming" deep dialogue has been squeezed into a floating widget, with its priority clearly demoted. There seems to be an implicit product logic at work: task execution is "real work," while discussion and thinking are not. But this gets things exactly backwards — strategy and creative ideas almost always emerge from the back-and-forth of conversation. Thinking is part of the work.

There's also a hard-to-excuse interaction bug: when you scroll to the bottom of the chat list, the content gets completely covered by the input box — you can neither see it nor click on it.

Why Is OpenAI Restructuring This Way?

Beyond the frustration, it's worth understanding the reasoning behind this consolidation. There is a coherent product logic at play.

Codex Was Never Just for Developers Anymore

The most fundamental driver is a shift in the user base. Codex was built for developers writing code — but over time, large numbers of non-technical users flooded in. According to official figures, Codex has over 5 million weekly active users, 20% of whom are general knowledge workers, and that segment is growing three times faster than the developer cohort.

These users are building decks, writing proposals, designing assets, and running marketing campaigns. They've redefined the product themselves. Given that, OpenAI's decision to fold Agent capabilities into GPT makes perfect sense.

The Real Signal Worth Watching: AI Agents Going Mainstream

If this were just two apps merging, it wouldn't merit much attention. The signal that really matters is this: AI Agents are transitioning from a developer-exclusive tool to a universal workbench for everyone.

Technical background on AI Agents: An AI Agent is an AI system capable of autonomously perceiving its environment, forming plans, and executing multi-step tasks — fundamentally different from the traditional chatbot's "one question, one answer" model. Agents can invoke external tools (browsers, code executors, API interfaces), decompose complex goals into subtasks, and complete them in sequence with minimal human intervention. This paradigm — "Agentic AI" — is the central direction for real-world large model deployment. OpenAI's Codex is a prime example: it doesn't just generate code, it runs, debugs, and iterates in a sandboxed environment, ultimately delivering a working program. As model reasoning capabilities improve, the task scope of Agents is expanding from programming into design, data analysis, content production, and virtually every other domain of knowledge work.

From Chat Tool to Digital Productivity Platform

The old mental model of AI was a chatbot: you ask, it answers; you want copy, it writes copy. That's no longer the reality. Today's AI can read local files, operate browsers and software, write code, generate complete reports, and execute multiple steps in sequence — delivering finished outputs, not just suggestions.

Many people hear "Codex" and think, "I don't write code, so it's not relevant to me" — that's a misjudgment. The future isn't one where everyone needs to write code. It's one where everyone can use Agents to turn ideas directly into deployable products.

You don't need to write code. But you will need to learn how to define goals, break down tasks, evaluate outputs, course-correct, and coordinate multiple Agents working in parallel. Codex hasn't been absorbed by GPT — rather, the "Agent-first way of working" that Codex represents is being democratized for every ordinary user.

Being able to command a full suite of digital production tools was once exclusive to developers. In the near future, every professional and every individual will have access to their own digital workbench and AI collaboration team. That's the deepest transformation signal embedded in this update.

Closing: The Product Experience Needs to Catch Up with the Model

The integration itself isn't wrong. Unifying the model, the tools, the account, and the file system is absolutely the right direction — and GPT 5.6's model capabilities genuinely hold up under scrutiny.

The problem is this: unifying the underlying capabilities does not mean stuffing every scenario into the same interaction box. Chat, Work, and Codex represent three fundamentally different relationships between human and machine. They can share the same model — but they shouldn't sacrifice their own experiential baselines in the process.

A great AI product shouldn't just be able to do things. It should always keep users informed about what it's doing, why it's doing it, and whether they're still in control. If even technically savvy users are guessing which button to press or which feature they're currently using, ordinary users will give up far sooner.

The model has sprinted far ahead. It's time for the product experience to catch up.