GPT-5.6 and ChatGPT Work: Everything OpenAI Announced

Most people joined our livestream expecting a model launch. OpenAI gave them a product reorganization instead.

Within 40 minutes, ChatGPT and Codex had moved into one desktop app. A new Work mode could pull from local files, connected apps, and the browser. Sites could turn an idea into a shareable web app. Computer Use could keep clicking in the background. GPT-Live could listen, speak, and translate at the same time.

Then Grant and Corey spent 90 minutes refreshing computers, testing a Dune browser game, and discovering the first law of launch-day benchmarking: the model you want is always available to somebody in the chat.

Corey remained, in his words, “entirely sixless” for most of the episode.

This companion guide reorganizes the full stream into a practical map of what OpenAI launched, what our early test showed, and how to use the new system without getting lost between Chat, Work, and Codex.

First up, the TL;DR

Here are the moments worth jumping to:

• OpenAI teases a ChatGPT and Codex “super app” (0:48): Corey spots the merged logos before the event begins.
• Background computer use changes the value equation (17:16): computer use becomes useful when you can keep doing other work.
• GPT-5.6's early visual strength (20:50): Grant calls out its website UI quality.
• The cost claim that grabbed Corey's attention (27:26): roughly one-third the cost of Fable on the demonstrated task.
• Voice listens, talks, and translates at once (35:30): the old one-speaker-at-a-time rhythm disappears.
• Codex becomes part of the ChatGPT desktop app (39:16): Grant catches the merger before they fully explain it.
• Why “Codex” scares away normal users (41:18): the product was already useful beyond coding, but the name hid that.
• The wise owl versus the Rottweiler (49:01): Fable plans and writes; Sol grabs the task and finishes it.
• The emerging two-model workflow (53:42): plan with Fable, build with GPT-5.6.
• Sol reportedly helped post-train Luna (55:38): the most consequential research claim got less attention than the app demos.
• The DuneScape head-to-head begins (1:04:07): Fable 5 High versus Terra Extra High.
• The new app may have too many doors (1:19:21): Chat, Work, and Codex are unified, but the choice remains confusing.
• Corey's multimodel design workflow (1:36:54): mock the design with an image model, select a palette, then hand the reference to the coding agent.
• Tools and harnesses now help decide the winner (1:41:00): integrations and interface can matter more than a few benchmark points.
• The cost-per-task gap (1:53:47): the chart showed Sol, Terra, and Luna substantially below Fable.
• Fable wins the lighting test (2:07:36): the live game output looked more dynamic and polished.
• The three-part AI stack (2:11:38): output quality now depends on the model, the harness, and the person steering both.

What OpenAI actually launched

The cleanest way to understand the announcement is to separate the intelligence layer from the work layer.

The intelligence layer is the GPT-5.6 family:

• Sol is the flagship for the hardest work.
• Terra is the balanced daily model.
• Luna is the fastest and cheapest option.
• Max gives one model more reasoning time.
• Ultra coordinates several agents across parallel workstreams.

OpenAI says Ultra runs four agents by default, while some evaluations used larger configurations. Sol reached 53.6 on Agents' Last Exam, 13.1 points above Claude Fable 5. OpenAI estimated that medium-reasoning Sol completed the work at roughly one-quarter of Fable's cost.

On Artificial Analysis, Sol Max came within one point of Fable while finishing 61% faster at about half the estimated cost.

The work layer is ChatGPT Work, which wraps GPT-5.6 inside Codex's agent system.

Work can gather context from apps and files, split a project into smaller jobs, create slides, sheets, documents, and web apps, then continue for hours. Scheduled Tasks can keep those workflows running when you leave.

OpenAI also folded the standalone Codex app into the new ChatGPT desktop app. The result has three visible modes:

• Chat for questions and conversation.
• Work for broad, multi-step knowledge work.
• Codex for software and technical workflows.

The same application now includes plugins, Sites, Scheduled Tasks, a built-in browser, local file access, and Computer Use.

That merger explains Corey's reaction at 41:18. Codex already handled writing, planning, research, and operational work. Its developer branding kept many people from discovering that.

ChatGPT Work puts the same operating system behind a friendlier door.

ChatGPT Work turns the chat box into a workspace

The most important demo had little to do with a benchmark. OpenAI showed an agent gathering information, working across files and apps, and returning finished material instead of another block of text.

That changes the unit of work. A normal chatbot handles a request. ChatGPT Work handles a project.

OpenAI's examples include reviewing thousands of leads, tracing broken follow-ups across CRM and email, checking launch plans against Jira and go-to-market schedules, comparing airline customer journeys, and automating conference preparation.

The practical workflow looks like this:

1. Give Work a goal and the source systems it may use.
2. Let it propose or begin a plan.
3. Watch the progress while it works in parallel.
4. Answer questions or change direction when needed.
5. Approve consequential actions.
6. Receive a finished document, analysis, dashboard, site, or updated workflow.

Corey focused on background computer use for a simple reason: watching an agent click slowly does not return your time.

OpenAI says Computer Use can click, type, move files, and operate across apps in the background. It can also become one step inside a scheduled task.

That is the difference between automation theater and an actual coworker. The useful agent is the one that disappears for 30 minutes while you do something else, then returns with a result worth reviewing.

Sites fixes the “I built it, now what?” problem

Corey's espresso story explains Sites better than the launch demo.

He bought an expensive espresso maker after realizing he was spending around $900 each month on coffee. Codex built an app that tracked the machine's payback period, savings per cup, and small achievements.

The app worked. Sharing it still required GitHub, Vercel, and several steps that had nothing to do with the idea.

At 43:25, Corey describes the frustration: the fun part ended, then deployment began.

Sites turns the output into a shareable URL inside ChatGPT. OpenAI positions it for live dashboards, project trackers, launch calendars, prototypes, portals, and interactive reports. The same site can update when its underlying information changes.

That feature will matter most to people who never planned to become developers.

A marketer can publish a campaign tracker. An operations lead can share a live process dashboard. A teacher can turn a lesson into an interactive tool. A person with an espresso problem can send a working calculator to friends before the joke gets cold.

GPT-Live teaches voice when to talk, listen, and stay quiet

The voice demo looked less dramatic than a 3D pelican, but it may reach more people.

GPT-Live uses a full-duplex architecture, which means it can listen and speak simultaneously.

It can acknowledge the user with “mhmm,” continue listening through a pause, handle an interruption, call a tool, or remain quiet. It can also perform live translation while the conversation continues.

The system separates conversation from deeper reasoning. GPT-Live handles the real-time exchange, then delegates search or complex reasoning to a frontier model behind the scenes.

Corey's test was beautifully ordinary. While ordering fried chicken, he asked ChatGPT to stay quiet. The model told him to say “come back” when he wanted it to return.

He finished the order, said the phrase, and the conversation resumed. That sounds small. Small interaction fixes are how voice shifts from demo to habit.

Sol, Terra, and Luna are jobs, not rankings

A three-model family encourages people to ask which one is “best.” The better question is which one deserves the assignment.

Use Luna when:

• The task is frequent, clear, and cost-sensitive.
• Fast iteration matters more than maximum judgment.
• You are running a high-volume agent workflow.

Use Terra when:

• You need a strong daily driver.
• The work has several steps but remains well-scoped.
• You want better reliability without spending Sol prices.

Use Sol when:

• The project is ambiguous, long-running, or high-stakes.
• The system must coordinate tools, files, and subagents.
• Judgment, persistence, or deep reasoning matters more than latency.

The models share a million-token context window, but their real cost depends on how many reasoning and output tokens they use to complete the job.

That last detail explains why Corey kept returning to cost per completed task.

Token prices alone resemble the sticker on a taxi. The useful number is the price when you reach the destination.

GPT-5.6 versus Claude Fable 5: the wise owl and the Rottweiler

The best comparison came from a post Corey read during the stream.

Fable was the wise owl: thoughtful, articulate, insightful, and strong at planning, writing, and architecture. It could also become overconfident, argumentative, or loose with implementation details.

Sol was the Rottweiler: fast, tenacious, literal, and determined to finish every item on the list. It was less elegant in some forms of writing, but more dependable at execution.

Dan Shipper offered a second metaphor. GPT-5.6 is a Porsche for everyday driving. Fable is a warp drive for the rare project that needs to cross the galaxy.

Those descriptions point toward a useful division of labor:

• Ask Fable to frame the problem, challenge the plan, and design the architecture.
• Ask GPT-5.6 to implement the plan, manage parallel tasks, and keep working until the checklist is complete.
• Let each model critique the other's output before anything important ships.

Grant and Corey independently landed on that workflow at 53:42.

It also fits our broader five-level AI proficiency framework: good projects begin with context and reusable systems, then agents execute inside those boundaries.

The counterpoint comes from developer Simon Willison. OpenAI's headline agent benchmark strongly favors GPT-5.6, but Claude Fable 5 scored 80% on SWE-Bench Pro versus 64.6% for Sol. OpenAI argues that roughly 30% of that benchmark may contain broken tasks.

Willison still says his early Sol experience has not beaten Fable on the complex coding jobs he gives Claude.

Both statements can be true. One benchmark may be flawed, and Fable may still be better for particular engineering workflows.

The correct model choice comes from your task, your prompts, your tools, and your tolerance for cost and rate limits.

What our live test actually showed

The stream attempted a head-to-head between Fable 5 High and Terra Extra High.

Grant asked both to build “DuneScape,” a browser-based 3D MMO inspired by RuneScape and Dune.

The result was entertaining, informative, and far from scientific.

Fable produced something first, but the initial game did not work. Terra discovered missing dependencies and tried to repair them.

Grant denied one permission, reversed the decision, then stopped a later repair. Corey correctly pointed out that the run had become contaminated by human intervention.

Grant also changed prompts, restarted tasks, and worked inside a product that was still rolling out. Sol was unavailable. The flagship comparison never happened.

What survived the chaos:

• Fable showed stronger lighting and shadows. Corey noticed more dynamic color changes across the player and floor.
• Terra behaved like a repair-oriented implementer. It identified setup problems before continuing.
• Both models created playable-looking foundations quickly. Neither delivered a polished game from one prompt.
• The wrapper affected the outcome. Permissions, dependencies, local files, preview behavior, and app state shaped the result as much as model intelligence.

At 2:07:36, Corey gives Fable the visual win.

At 2:08:08, he gives the necessary disclaimer: Terra is not Sol, and one improvised build cannot settle the model race.

The test still taught a durable lesson. A strong coding agent benefits from a visual target.

Corey now mocks up the product with an image model, chooses a palette, and hands the reference image to Codex. The coding model receives a concrete design instead of a paragraph full of adjectives.

Cost and limits will decide which agents reach the office

Agentic work multiplies token usage. A single request can branch into research, file analysis, tool calls, subagents, verification, and several rounds of revision.

During the stream, Grant's account fell to 7% of its five-hour usage allowance. Corey recalled Grant running roughly 808 million tokens in one week.

Those numbers turn model efficiency from an API footnote into a budget decision.

OpenAI's published results emphasize completed work per dollar. It reports Terra and Luna beating Fable on Agents' Last Exam at around one-sixteenth the estimated cost.

On its Coding Agent Index comparison, OpenAI says Sol used less than half as many tokens and finished in less than half the time of Fable, with about one-third lower estimated cost.

Corey's enterprise argument at 1:49:47 is equally important.

A brilliant product with unpredictable lockouts becomes hard to standardize across a company. Teams can budget dollars. They struggle to budget “the tool may stop working sometime this afternoon.”

OpenAI has its own usage limits, and Ultra will consume them faster.

The competitive advantage comes from predictability: clear quotas, understandable overages, and enough capacity that employees can trust the system during real work.

The quiet research story: AI training AI

The strangest line in the launch was also the easiest to miss.

Corey says OpenAI described Sol as helping autonomously post-train Luna.

At 56:04, he explains the mechanism simply. Pre-training builds broad knowledge from large datasets. Post-training shapes behavior: how the model answers, follows instructions, uses tools, and handles different tasks.

Grant's working theory is that Sol may have acted as an evaluator, reading Luna's outputs and grading them. The stream did not establish the exact process, so that detail remains an inference.

OpenAI's published material confirms that GPT-5.6 is being tested on research debugging, kernel optimization, training recipes, machine-learning experiments, and improving another model.

The company reports a 16.2-point gain over GPT-5.5 on its aggregate recursive self-improvement evaluation. It also says internal agentic token usage rose about 22-fold in six months.

The near-term change is more mundane than a self-improving superintelligence.

Researchers can run more experiments, debug more training systems, and evaluate more candidate models with the same human team. That compounds. The lab that shortens its own research loop gains an advantage before the public model appears.

The unresolved question is how much judgment humans retain inside that loop.

“The model helped improve another model” can describe anything from automated grading to meaningful experiment design. OpenAI needs to show the workflow, the failure modes, and the point where researchers overruled the agent.

The model, the harness, and you

Corey's strongest insight arrives near the end of the stream: the industry is outgrowing simple model rankings.

A model supplies intelligence. A harness decides what that intelligence can access, how long it can work, whether it can branch into subagents, how it handles permissions, and what it produces.

The user supplies the context, constraints, examples, and judgment.

That creates three separate failure points:

• A strong model inside a weak harness cannot finish the job.
• A strong harness around the wrong model wastes time or money.
• A capable system with vague instructions produces polished confusion.

ChatGPT Work is OpenAI's bet on the harness.

The company is bringing Codex's persistence, tools, local access, browser, schedules, and multi-step execution to people who never planned to open a terminal.

Fable may remain the more insightful planner. Sol may become the more relentless finisher. Luna may win simply because a business can afford to run it thousands of times.

The winning product will combine enough intelligence with the least friction between intention and finished work.

Your action plan

You do not need to rebuild your AI workflow around the launch today. Test one layer at a time.

1. Start with a task you already understand

Give Work a job where you know what good looks like. Use a familiar monthly report, launch checklist, research brief, or meeting-prep workflow.

Familiarity makes failures obvious.

2. Choose the model by workload

Use Luna for volume, Terra for everyday execution, and Sol for hard judgment or long projects.

Raise reasoning effort only when the task earns the added time and cost.

3. Give visual work a visual reference

Create a mockup first. Pick the layout and palette. Then ask the coding agent to build toward that image.

“Make it beautiful” leaves too much unresolved.

4. Let the agent run in the background

A task that requires constant supervision has limited leverage.

Use background computer use and schedules for bounded workflows, then review the finished output and action log.

5. Publish small tools through Sites

Turn a dashboard, calculator, tracker, or prototype into a URL before you spend time building infrastructure.

Shareability is part of the product test.

6. Keep consequential actions gated

Local files, email, CRM data, and browser control increase the blast radius of a mistake.

Require approval for external messages, deletions, purchases, account changes, and sensitive data transfers.

7. Use more than one model when the job deserves it

Let one model plan, another implement, and a third verify.

The best workflow may look less like picking a champion and more like building a small team.

What to watch next

Five signals will tell us whether this launch changes daily work:

• Do normal users adopt the desktop app? Background computer use and local files matter only after people leave the browser.
• Can OpenAI explain Chat, Work, and Codex clearly? One app reduces fragmentation, but three modes can still feel like three products.
• Does Sol's benchmark efficiency survive real company workflows? Completed tasks and correction time matter more than a leaderboard.
• Can agents stay reliable across hours of work? One unnoticed error can spread through every later step.
• Will pricing remain predictable at scale? Cheap models can become expensive when subagents multiply the work.

OpenAI launched a family of models.

Its larger bet is a new default interface for labor: describe the outcome, connect the context, approve the risky steps, and let an agent carry the work across tools.

The model race will keep producing a new winner every few weeks. The harder contest is building the system people trust with an afternoon of unsupervised work.

That leaves one question worth tracking:

Will the best raw model win, or will the best harness make model loyalty irrelevant?