OpenAI has released the GPT 5.6 series of models, comprising three tiers—Soul, Terra, and Luna—designed for complex agent workflows, everyday tasks, and high-frequency, low-cost tasks, respectively. Simultaneously, OpenAI has launched ChatGPT Work, a desktop app, and Hosted Sites to create a complete execution pipeline spanning task entry, environment integration, and result delivery. The Soul model handles complex planning and reasoning, while Terra and Luna manage routine tasks and batch processing, respectively, with hierarchical routing balancing cost and performance. Ultra Mode supports parallel processing across multiple agents, but the core challenge lies in the orchestrator’s task decomposition and conflict resolution. The article emphasizes that trustworthy agents require four layers of mechanisms: least privilege, operational tiering, process auditing, and transactional execution. Enhanced security capabilities in GPT 5.6 also demand more stringent access control designs.Author and source: Leiphone
At 1:00 AM Beijing Time, GPT 5.6 was unveiled at the OpenAI event.
This launch did not focus solely on one model but introduced ChatGPT Work, the brand-new ChatGPT desktop app, Hosted Sites, and the GPT 5.6 series models: Soul, Terra, and Luna.
Individually, these appear to be several distinct features; together, they actually serve the same purpose: transforming ChatGPT from a tool that generates responses into an execution system capable of receiving tasks, understanding context, invoking tools, manipulating environments, and delivering results.
Traditional chat products primarily handle "input" and "output." The user asks, the model responds, and the task typically ends within the chat window. An execution system is far more complex—it must handle task decomposition, context management, tool invocation, state tracking, permission control, and result validation.
Financial analysis, Excel updates, PPT generation, desktop application operations, web hosting, and multi-agent collaboration can all be understood within this technical roadmap.
You can start by examining the product flow.
The execution chain link ChatGPT Work serves as the task entry point.
The user's request is no longer just a clear piece of text, but a task-oriented assignment with a goal—such as identifying internal use cases from Slack and employee feedback, combined with scheduled interviews; or parsing financial data to perform variance analysis, update forecasts, and generate reporting materials and shareable pages.
The challenge with this task lies in orchestration. The system must determine which data sources are needed, the order in which to read them, how to process them, which steps can be automated, and where user confirmation is required.
Simple Q&A only needs to process the current input, while Agent workflows must maintain task state: which materials have been used, what intermediate conclusions have been reached, and which assumptions remain unverified.
After resolving the task entry, the next step is naturally environment integration. Real-world work rarely exists within a single chat window; it is more often spread across local files, browser tabs, spreadsheets, notes, emails, and collaboration tools.
This is the purpose of the desktop app. While the web version primarily relies on file uploads and cloud connectors, the desktop version can access local files, browser tabs, and other applications.
The demonstrations of Apple Notes organization, local folder access, Chrome tab analysis, and table visualization in the keynote essentially involve bringing ChatGPT into the user’s real work environment.
But after connecting to the environment, the problem doesn't automatically become simpler—it adds another layer of context engineering.
The model cannot fit all files, browser tabs, and browsing history from a user’s computer into its context window. It must first determine which content is relevant to the task, then convert various formats—such as PDFs, Excel files, web pages, PPTs, and notes—into machine-processable representations. This process involves file indexing, semantic retrieval, context compression, citation tracking, and conflict resolution.
For example, within the same project, PDFs, PPTs, Slack messages, and Excel spreadsheets may all exist simultaneously, and the information may even contradict each other. The Agent cannot simply stitch the materials together—it must determine which sources are most up-to-date, which are trustworthy, and which are merely background material. The more context there is, the greater the risk of errors if filtering and citation are not handled properly.
After connecting to and understanding the environment, the results must still be deliverable. Hosted Sites fills this gap.
Previously, large models primarily output text, code snippets, or static files, requiring users to move the results into other tools for further processing. Hosted Sites transform outputs directly into web pages, dashboards, internal tools, or interactive prototypes, making them better suited for lightweight use cases such as temporary dashboards, project presentations, and product prototypes.
However, the delivery layer must be stable and cannot rely solely on free-form model generation. When an Agent invokes tools, it requires a structured tool protocol: what are the input fields, how are the results represented, how are failure states handled, which operations are read-only, and which operations have side effects.
For tasks like "update forecast," directly having the model modify the Excel file after understanding it carries high risk. A more reliable approach is to break the action into steps: read the cell values, verify the formulas, generate a diff, wait for confirmation, and then write back to the file.
Viewed this way, the execution pipeline can be divided into three stages: ChatGPT Work receives the task, the desktop app handles the environment, and Hosted Sites deliver the results. Once the pipeline is set up, the issue shifts to the next level: it’s impossible to run all these steps with a single model—the backend must include model orchestration.
Model scheduling GPT 5.6 is now divided into three tiers: Soul, Terra, and Luna. Soul is designed for complex agent workflows, Terra for everyday tasks, and Luna for high-frequency, low-cost tasks.
The focus of this hierarchy is on orchestration. In Agent scenarios, cost and latency are amplified. A complex task may involve reading long documents, context compression, multiple tool calls, code generation, result validation, and several iterations.
Calling the strongest model at every step increases costs and response time; using a low-cost model throughout may lead to instability in planning, reasoning, and critical operations.
A more rational approach is hierarchical routing: summarization, categorization, format conversion, and batch processing can be handled by low-cost models; complex planning, long-context reasoning, code generation, financial analysis, and high-risk operations can be assigned to more powerful models; intermediate steps dynamically switch based on task status. Users see a ChatGPT, while internally, the system manages model selection, context allocation, and tool orchestration.
When a single model is insufficient to handle complex tasks, multi-agent systems enter this scheduling framework.
Ultra Mode can be understood as breaking down complex tasks and assigning them to multiple agents for parallel processing: one agent reads the materials, another processes the tables, a third generates the page, and a fourth checks for consistency, before finally integrating the results. This approach improves speed and enables a degree of cross-verification.
The real challenge lies in the orchestrator. It must decide how to break down tasks, what context each agent receives, how to handle conflicting results, when to stop, how to avoid redundant work, and how to control costs. Without a stable scheduling layer, multi-agent systems only lengthen error chains and make troubleshooting more difficult.
Model scheduling also introduces another issue: how to evaluate whether it has actually improved.
These systems cannot be evaluated solely on traditional QA benchmarks. The发布会 mentioned Terminal Bench, BrowseComp, and Agent’s Last Exam, which better reflect code execution, complex information retrieval, and long-term professional tasks, respectively. They are more aligned with Agent scenarios because the model must continuously plan, search for information, perform actions, and make adjustments along the way.
However, real-world business environments are difficult to fully cover by standard test sets. Real tasks often involve access restrictions, dirty data, legacy systems, and internal organizational inconsistencies. For systems like GPT 5.6, more critical metrics should be failure rate, human takeover rate, average completion time, tool invocation success rate, result verifiability, and cost per task.
Model scheduling addresses the question of “which model to use, at what cost, and by what method to complete the task.” When the system begins actually executing the task, the next question becomes even more important: Can users trust it to do so?
The closer the Trusted Boundary Agent system is to the real working environment, the more specific the security issues become.
Previously, model security focused primarily on output content, such as whether it generated incorrect, sensitive, or harmful information. With the advent of the Agent phase, risks now center on actions: which files were read, which tables were modified, which tools were invoked, whether messages were sent, whether code was submitted, or whether business systems were updated.
The keynote mentioned that GPT 5.6 has significantly improved cyber capabilities, enabling it to detect vulnerabilities and generate patches. While this capability is valuable for defense, integrating it into a general-purpose agent product requires stricter permission design. A model capable of reading files, writing code, operating browsers, and accessing enterprise systems must be confined within clearly defined boundaries.
A trusted agent requires at least three layers of mechanisms.
First is the principle of least privilege: grant access only to what a task requires, avoiding exposure of excessive files, connectors, or applications for simple tasks.
Second is operational tiering. Actions such as reading data, generating drafts, editing files, sending messages, submitting code, and updating financial models have different risk levels and should therefore have distinct confirmation logic.
Third is process auditing. The system must log what data the model accessed, what changes it made, the basis for its decisions, and which conclusions stem from raw data versus model inference. Scenarios such as finance, legal, security, and healthcare rely particularly heavily on audit trails.
Fourth is transactional execution. Whenever an Agent can modify a live environment, it should first generate a plan and a change diff for review by the user or a validator, then submit all changes at once—rather than making incremental, ad-hoc modifications. Any action such as editing an Excel file, moving files, sending messages, or committing code should include a dry run, diff review, confirmation, and rollback capability.
This is similar to the concept of database transactions. The key is not to ensure that every step succeeds, but to prevent uncontrolled intermediate states in case of failure. Without a transaction mechanism, an agent would struggle to handle high-value tasks, as users wouldn’t be able to determine what changes were made or safely undo them.
In enterprise scenarios, an observation system must also be deployed. During the execution of long-running tasks, the system should log the input, output, tool calls, model version, duration, failure reasons, and human intervention points for each subtask. Otherwise, if the result is incorrect, it will be difficult to determine whether the issue lies in model inference, context retrieval, tool interfaces, or permission configurations.
This type of observability will become a foundational capability of the Agent platform. Traditional software relies on logs, distributed tracing, and monitoring metrics; Agent systems similarly require clear execution traces. Especially when multiple Agents run in parallel, the absence of clear tracing makes troubleshooting increasingly costly as complexity grows.
The trusted boundary is also why the financial demo is more worth attention than the 3D page. Generating a page primarily tests coding and interaction skills, while updating a financial model involves data consistency, formula accuracy, assumption transparency, and accountability.
Which cell did the model change? Are the numbers in the PPT consistent with the source table? Is there a clear basis for the changes in the forecast? These questions determine whether it can be integrated into the enterprise’s core workflow.
Overall, the technical roadmap presented at the GPT 5.6 launch is now fairly clear: start by assigning tasks via ChatGPT Work, then integrate into real-world environments through the desktop app, and complete deliveries using Hosted Sites; beneath this, model orchestration is handled by Soul, Terra, Luna, and Ultra Mode; finally, risk is managed through permissions, auditing, transaction controls, and observability mechanisms.
These layers are interconnected. The execution pipeline determines whether ChatGPT can start the task, model scheduling determines whether it can continue running at a reasonable cost, and the trusted boundary determines whether users dare to entrust critical tasks to it.
The value of GPT 5.6 will ultimately be determined not by the demo effects presented at the launch, but by its stability in real-world use.
