GPT-5.6 and the New Codex: Sol, Terra, and Luna Models and New Features

Updated: July 12, 2026.

Table of Contents

• Quick Answer
• What GPT-5.6 Is and What Codex Has to Do with It
• Sol, Terra, and Luna: Which Model to Choose
• What Improved in GPT-5.6
• What’s New in Codex
• How to Choose an Operating Mode
• Practical Use Cases
• Pricing and Economics
• Limitations and Security
• How to Roll Out Codex Across a Team
• FAQ

Quick Answer

GPT-5.6 is OpenAI’s new model family, and Codex is the agentic workspace where these models can read files, write and test code, use tools, work with applications, and carry long tasks through to completion. On July 9, 2026, OpenAI announced general availability for three GPT-5.6 variants: Sol, Terra, and Luna — in ChatGPT, Codex, and the API.

Sol is built for the hardest problems, Terra offers a balance of quality and cost, and Luna delivers maximum speed and the lowest price. At the same time, Codex became much more than a standard coding assistant: it now includes plugins for roles and tools, inline annotations on outputs, Sites for publishing interactive apps, hooks, mobile access, Remote SSH, automations, and new multi-agent modes.

The main takeaway for business and engineering is simple: you should not choose “the smartest model,” but the combination of task → reasoning level → control boundary. For high-volume classification and simple edits, Luna is a fit; for day-to-day engineering work, Terra makes sense; and Sol is the right choice for architecture, complex debugging, research, and long autonomous tasks.

What GPT-5.6 Is and What Codex Has to Do with It

GPT-5.6 is not a single model, but a family with three tiers. OpenAI refers to the flagship model as Sol, the balanced model as Terra, and the fastest, most affordable model as Luna. As of July 12, 2026, the family is rolling out in ChatGPT, Codex, and the Responses API. The official OpenAI announcement is dated July 9, 2026.

Codex is the product layer around the models. If a normal chat mainly responds in text, Codex can inspect a repository, modify files, run commands and tests, compare results against requirements, and return a verifiable artifact. In newer scenarios, it also works with documents, spreadsheets, presentations, the browser, enterprise apps, and visual materials.

That is why the phrase “the new Codex on GPT-5.6” combines two changes:

1. The model got stronger at coding, tool use, computer use, design, and long tasks.
2. Codex itself gained new ways to connect context, manage agents, verify outputs, and publish artifacts.

This distinction matters. The model is responsible for reasoning and generation, while Codex handles the workflow: environment access, tools, permissions, parallel tasks, files, review, and handing results back to a human.

Sol, Terra, and Luna: Which Model to Choose

Model	Built For	Where to Use It	API Price per 1M Tokens, Input/Output
GPT-5.6 Sol	The most complex and longest tasks	Architecture, deep debugging, research, security, autonomous implementation	$5 / $30
GPT-5.6 Terra	Balance of quality, speed, and cost	Daily development, analysis, documents, standard agent workflows	$2.50 / $15
GPT-5.6 Luna	Speed and high volume	Classification, extraction, simple edits, quick subtasks	$1 / $6

Prices are taken from the official GPT-5.6 release page and are current as of the article update date. They do not include the cost of your infrastructure, tools, or reruns.

When to Choose Sol

Sol makes sense when a mistake or an incomplete result costs more than the extra tokens. Typical examples include migrating a large application, tracking down a rare race condition, designing a permissions system, auditing a complex codebase, preparing a financial model, or building an interface that requires repeated visual checks.

On Terminal-Bench 2.1, Sol scored 88.8%, and Sol Ultra scored 91.9%. On SWE-Bench Pro, Sol scored 64.6%. These numbers are useful as a signal of overall capability, but they do not guarantee the same success rate on your stack. A benchmark measures a specific set of tasks, while production adds legacy code, incomplete requirements, and internal tools.

When to Choose Terra

Terra is a sensible starting point for most teams. It costs half as much as Sol for both input and output, while OpenAI positions it as a model with quality competitive with GPT-5.5. In official tests, Terra scored 63.4% on SWE-Bench Pro and 87.4% on Terminal-Bench 2.1 — close to Sol on tasks that do not require maximum reasoning headroom.

Terra should be your default model for feature work, medium-sized refactoring, tests, SQL, log analysis, preparing technical documents, and working through tracker tickets. More difficult or stalled tasks can then be escalated to Sol.

When to Choose Luna

Luna is designed for speed and volume. It costs five times less than Sol for both input and output, yet it still scored 62.7% on SWE-Bench Pro and 84.7% on Terminal-Bench 2.1 in OpenAI’s published configuration.

Luna is a good fit for initial issue triage, generating repetitive tests, data formatting, short knowledge base queries, field extraction, and simple transformations. But the savings disappear if a lightweight model makes frequent mistakes and needs multiple reruns. What matters is not the price of one call, but the price of the accepted result.

What Improved in GPT-5.6

Long Agentic Tasks

The main change is not flashier answers to a single prompt, but the ability to stay aligned with a goal across many steps. The model has to read context, choose tools, make changes, verify them, notice failure, and adjust the plan. That is exactly the cycle Codex needs.

In long-context work, GPT-5.6 Sol scored 91.5% on OpenAI MRCR v2 in the 256K–512K range and 73.8% in the 512K–1M range. However, a large window does not mean perfect memory: the repository structure, decisions, and acceptance criteria are still better captured in project files.

Computer and Browser Work

Sol scored 62.6% on OSWorld 2.0, and with Ultra it reached 92.2% on BrowseComp. That makes the model more useful for tasks where you need to do more than write code — open an app, verify the UI, gather data from multiple sources, or complete a workflow end to end.

The practical implication: testing the result becomes part of executing the task. An agent can create a page, open it, detect overflow or a broken button, fix the code, and run the check again. That is closer to how an engineer works than to autocomplete.

Design and Ready-to-Use Work Artifacts

OpenAI separately highlights improvements in interfaces, presentations, documents, and spreadsheets. GPT-5.6 follows references better, spots visual issues, and can refine outputs after rendering. That matters for Codex: the agent evaluates not only the source code, but also what the user will actually see.

Programmatic Tool Calling

In the Responses API, the model can write and execute an in-memory program that coordinates tools and processes intermediate results. This is called Programmatic Tool Calling. This approach reduces the need to return each intermediate object to the main context and helps build efficient, complex workflows. OpenAI also says the mechanism is compatible with Zero Data Retention.

Multi-agent and ultra

Multi-agent lets you run several sub-agents in parallel and synthesize their work in a single request. The ultra mode uses parallel work streams for especially complex tasks. In Codex, ultra is available to Plus users and higher tiers with access to GPT-5.6; max is available to all Codex users with access to the family.

Parallelization is useful when the work can truly be split up: one agent explores the API, another analyzes tests, and a third checks security. For a small, linear task, multi-agent only adds overhead and makes validation more complicated.

What’s new in Codex

Plugins: role, instructions, and tools in one package

Plugins tailor Codex to a specific role and work environment. They can combine skills, instructions, MCP servers, and app connections. On June 2, 2026, OpenAI introduced six role-based plugins and described how Codex can be used beyond development—for analysts, marketers, researchers, legal teams, and operations teams. Official overview of new Codex features.

For a company, a plugin is a way to package a repeatable process: where to get the data, which templates to use, which tools to use, and what format to return the result in. That is more reliable than storing a huge prompt in a corporate wiki.

Skills: reproducible workflows

A skill contains instructions, resources, and scripts for a specific type of work. For example, a separate skill might describe creating a presentation, processing a spreadsheet, implementing a design from Figma, or deploying an app. Skills can be used in the Codex app, CLI, and IDE, and team skills can be stored in the repository.

The strength of skills is versioning. A team can change the review process or report format in one place, validate the change through a pull request, and give all agents the new version of the procedure.

Annotations: edits directly on the result

Annotations let you point to a specific part of an artifact and ask Codex to change exactly that: a UI block, a section of a document, or part of a visual output. This narrows the gap between saying “make the headline better” and the exact context of where the headline is and what is wrong with it.

Sites: from output to a shareable URL

Sites is a preview feature for creating interactive sites and apps that can be shared with a workspace via link. This changes the final step of agent work: the output can be not an archive of code, but a working internal tool, calculator, dashboard, or explanatory visualization.

Sites does not replace production engineering. For a public service, you still need a domain, monitoring, security, redundancy, and a release process. But for prototypes and internal tools, the path from idea to feedback becomes shorter.

Hooks: control before and after actions

Hooks are now generally available and can check prompts for secrets, run validators, log events, create memory, or apply repository rules. This is an important enterprise feature: quality and security cannot be left to the model alone.

A hook can be placed before a risky action, after a file change, or before a task is completed. For example, an organization can block the sending of keys, automatically run a linter and security scan, and then attach the result to the agent’s report.

Mobile Codex and Remote SSH

Codex has arrived in the ChatGPT mobile app in preview. A user can answer the agent’s question, adjust the task, or confirm the next step while the work is running on a laptop, devbox, or remote machine. Remote SSH makes it possible to work with remote environments without moving the whole project to a local computer. OpenAI described these capabilities on May 14, 2026.

Automations and background tasks

Automations run instructions and skills on a schedule and send the result to a review queue. This approach works for issue triage, CI summaries, release briefs, and regular error checks. Automation should end with a verifiable artifact, not uncontrolled changes to production.

Memory and connected apps

The new Codex can use context from work tools and take user preferences into account. This helps bring together documents, reports, and tasks from scattered sources. At the same time, the cost of access mistakes increases: the agent should see only the data needed for the specific task.

How to choose a working mode

We propose the AI dawn framework “Three selection rings”.

Ring 1. Task

First, define the complexity and the cost of an error.

• Low complexity, low risk: Luna.
• Medium complexity, standard feature work: Terra.
• High complexity or expensive mistakes: Sol.
• Several independent complex directions: Sol with max or ultra.

Ring 2. Reasoning

Do not increase reasoning automatically. Start with the standard mode and scale it up when there is a signal: the task is stuck, there are many constraints, deep research is required, or the model needs to reconcile multiple systems.

max gives the model more compute budget. ultra coordinates parallel work streams. This is useful for architectural research or a large migration plan, but excessive for renaming a field.

Ring 3. Control

The more autonomy, the stricter the guardrails:

• limited file scope;
• network only when necessary;
• minimum permissions in apps;
• hooks for secrets and checks;
• tests and static analysis;
• human approval before deployment, deletion, and external sending;
• a log of commands, links, and changes.

The right model without control remains a risk. A simpler model with good tests and clear criteria often delivers more business value.

Practical scenarios

Feature development

Terra reads the task and the repository, proposes a plan, implements the change, and runs tests. Sol joins in if the architecture, data, or complex compatibility are affected. Luna can prepare mechanical test cases and documentation.

Large project migration

Sol Max explores dependencies and creates a migration map. Parallel agents analyze the frontend, backend, and CI. A human approves the plan, after which the changes are broken into small, verifiable stages. Ultra is useful during the research phase, but it does not replace step-by-step integration.

Analytics and knowledge work

Codex gathers context from documents and apps, processes data with scripts, builds a spreadsheet or presentation, and checks it against the template. Terra is suitable for most of these tasks; Sol is for complex financial, legal, or scientific analysis.

Internal tool

The team describes the process in natural language, Codex builds the interface, tests it in the browser, and publishes a preview through Sites. Annotations speed up feedback: the process owner points to a specific element and writes the edit request without a long technical specification.

Operational automation

Scheduled automation collects CI errors, groups them, and creates a concise report. Hooks verify that no secrets are exposed and that links are valid. Luna is a good fit for sorting, Terra for root-cause analysis, and Sol for rare, complex incidents.

Pricing and economics

Comparing plans by tokens is only the first layer. The full cost of a task includes:

• input and output tokens;
• retry attempts;
• calls to external tools;
• human time for task assignment and review;
• the cost of errors;
• execution infrastructure;
• support for skills, plugins, and integrations.

A simple example: if Luna costs five times less than Sol but needs four reruns and an hour of manual fixes, it may end up costing more. And the reverse is also true: using Sol for a thousand simple classifications is an unnecessary premium.

A useful metric is cost per accepted task, the cost of an accepted result. To calculate it, log the cost of all attempts and reviews, then divide by the number of tasks that meet quality criteria. Model routing should be based on this metric, not on impressions from one polished answer.

GPT-5.6 also introduces more predictable prompt caching: explicit cache breakpoints and a minimum cache lifetime of 30 minutes. Cache writes for GPT-5.6 and newer models are billed at 1.25x the normal input price, and reads get a 90% discount. For long, stable instructions, this can reduce the cost of repeat tasks.

Limitations and security

A benchmark is not the same as your production environment

Published results are measured by OpenAI or the listed test authors on specific datasets. They do not prove that the model will solve 64.6% of your tasks. Run your own eval on 30–100 representative cases, including failed and edge cases.

An agent can be confidently wrong

Codex can write a working test that checks the wrong behavior, or refer to a false assumption. Require evidence: a diff, commands, test results, documentation links, and a description of limitations.

Tools expand the attack surface

Access to a browser, shell, CRM, and cloud turns a text error into a potential action. Use a sandbox, domain allowlists, minimal roles, and confirmation for dangerous operations. Content from the internet and documents should be treated as untrusted data: it may contain prompt injection.

Multi-agent setups increase management complexity

Several agents can explore independent areas faster, but they may duplicate work, contradict each other, or modify overlapping files. You need an integration owner, clear task boundaries, and a single definition of done.

Feature availability depends on plan and rollout

OpenAI rolls out features gradually. Sol, Terra, Luna, max, ultra, Sites, or mobile access may differ by plan, region, and workspace type. Before implementation, check the interface and official documentation, not just the article.

How to implement Codex on a team

1. Choose one process. Don’t start with the goal of “implementing AI.” Pick feature triage, test updates, or report preparation.
2. Establish a baseline. Measure time, error count, and the share of tasks that pass review on the first try.
3. Create acceptance criteria. Verification commands, tests, report structure, and prohibited actions should be documented.
4. Set Terra as the default. Use Luna for low-cost sub-tasks and Sol for escalations on complex cases.
5. Package the process into a skill or plugin. That makes the instruction versionable and repeatable.
6. Add hooks and minimal permissions. Check secrets, formatting, tests, and security automatically.
7. Run a limited pilot. Compare 30–100 tasks against the baseline, not a single demo example.
8. Measure cost per accepted task. Include retries and review time.
9. Expand autonomy step by step. Start with read-only and recommendations, then branch changes, then actions that require approval.

FAQ

Is GPT-5.6 already available to everyone?

OpenAI announced general availability on July 9, 2026, along with a gradual global rollout. Access depends on the product and plan. In Codex, Free and Go users get Terra, while Plus, Pro, Business, and Enterprise can choose Sol, Terra, and Luna; specific availability may appear gradually.

How is GPT-5.6 different from Codex?

GPT-5.6 is a family of models that reason and generate output. Codex is an agentic environment that gives the model files, tools, apps, permissions, command execution, parallel work, and a review interface.

Which is better for programming: Sol or Terra?

For most everyday tasks, start with Terra. Choose Sol for complex architecture, long autonomous changes, deep debugging, and cases with a high cost of error. The decision should be confirmed by your own eval and the cost of an accepted task.

What is Luna for?

Luna is useful for fast, high-volume operations: classification, data extraction, simple edits, and mechanical sub-tasks. It is the cheapest model in the family, but it requires quality control when the task is ambiguous.

What are max and ultra in Codex?

Max gives a complex task a larger reasoning budget. Ultra coordinates multiple parallel agent streams. Ultra makes sense when a task can be split into independent investigations; for small, linear work it is overkill.

Will the new Codex replace developers?

Codex automates ever-larger parts of development and knowledge work, but production still requires task definition, architectural decisions, access management, review, accountability, and business understanding. The practical model is not “an agent instead of a team,” but a team that delegates verifiable parts of the work to agents.

Is it safe to give Codex access to corporate systems?

Only with minimal permissions, a sandbox, logging, hooks, a network allowlist, and confirmation of dangerous actions. Don’t give the agent broad production access for convenience. Start with read-only and a test environment.

What new Codex features matter most?

For an individual user: skills, annotations, mobile access, and improved result verification. For a team: plugins, hooks, Remote SSH, Automations, and programmatic access tokens. For complex projects: max, ultra, and multi-agent.

Bottom line

GPT-5.6 strengthens Codex exactly where agent systems usually broke down: long tasks, tool use, browser work, interfaces, and complex context. But the more important change is the product maturity of Codex itself. Plugins, skills, annotations, Sites, hooks, automations, and remote access turn it from a code generator into a work execution environment.

A practical strategy for 2026: Terra as the default model, Luna for low-cost scale, Sol for complex and expensive tasks; max and ultra only where extra reasoning and parallelism pay off. Quality should be measured on your own tasks, and autonomy should increase together with tests, permissions, and human review.