Beyond Chat

OpenAI's GPT-5.6 release looks, at first, like a familiar product segmentation exercise: Sol at the frontier, Terra in the middle and Luna at the efficient end. That interpretation is convenient, but it misses the most important development.

GPT-5.6 is better understood as a programmable hierarchy of cognition. The model tier determines the available reasoning ceiling. Reasoning effort controls how much computation is applied to a task. Standard and Pro modes change the execution budget again. ChatGPT Work, Codex, GitHub Copilot and the Responses API place those models inside different tool, context and permission environments. Programmatic Tool Calling, persisted reasoning, computer use and multi-agent execution then determine how that cognition can act.

The practical question is no longer simply, Which model is best?

Which combination of model, reasoning budget, execution surface, tools, validation and escalation policy gives this task the best reliable outcome at an acceptable cost?

That is a systems-design question. It is also where most of the value lies.

Graph Technologies' position: Sol should be treated as an escalation tier for ambiguity, consequence and difficult judgement. Terra is the strongest default for recurring professional and engineering work. Luna should handle high-volume tasks where correctness can be specified and checked. The execution surface should be selected independently: Copilot when the editor is the centre of gravity, Codex when repositories and machines are central, and Work when the intended output is a finished professional artefact.

How to Read the Evidence

This article separates four kinds of statement:

• Verified fact: a documented capability, price, benchmark result or availability statement from an official source.

• Technical interpretation: an inference about what that capability means for system design or workflow performance.

• Operational recommendation: a proposed deployment pattern based on engineering trade-offs.

• Graph position: an explicit editorial judgement from Graph Technologies.

The benchmark numbers in this article are reported by OpenAI unless another source is named. They are useful evidence, but they are not a substitute for task-specific evaluation. Graph Technologies has not yet published a controlled Sol-versus-Terra-versus-Luna evaluation dataset. The accompanying evaluation workbook is intended to make that possible and to keep future product reviews methodologically consistent.

One Family, Three Levels of Computational Commitment

OpenAI describes Sol as its flagship, Terra as a balanced model for everyday work and Luna as its most cost-efficient model. The three names are intended as durable capability tiers that can advance on their own cadence rather than temporary suffixes attached to one release.

The simplest useful interpretation is not “large, medium and small”. It is expensive judgement, sustained production work and efficient throughput.

The pricing matters because output tokens are six times more expensive than input tokens across all three tiers. A workflow that allows an agent to generate large speculative plans, repeated explanations or unnecessary rewrites can spend more than its model choice initially suggests.

The difference between the tiers is also task-dependent. On OpenAI's published Big Finance Bench results, Terra is close to Sol, scoring 51% against 53%, while Luna falls to 36%. On Terminal-Bench 2.1, the family is more tightly grouped: 88.8% for Sol, 87.4% for Terra and 84.7% for Luna. On security evaluations, the separation becomes much larger. Sol reaches 73.5% on ExploitBench 2, while the launch data reports materially lower performance for smaller tiers.

Technical interpretation: the tier gap grows when a task requires sustained judgement, recovery, adversarial reasoning or the integration of weak signals. It narrows when the environment provides clear feedback, executable tests or structured tools.

This is why Luna can be a strong model inside a well-instrumented pipeline and a poor choice as an unsupervised analyst. The quality of the surrounding system changes the amount of intelligence the model itself must supply.

Reasoning Is a Runtime Control, Not a Personality Setting

Reasoning effort is often described casually as how “deeply” the model thinks. That is directionally correct, but operationally incomplete.

In the Responses API, supported effort values are model-dependent and can include none, minimal, low, medium, high and xhigh. Lower settings favour speed and lower token usage. Higher settings allow the model to apply more reasoning to planning, alternatives, tool use and recovery.

GPT-5.6 also supports two reasoning modes in the Responses API:

• standard, the default;

• pro, which performs more model work and is intended for difficult tasks that can tolerate additional latency and token usage.

Mode and effort are independent. A request can use Pro mode at medium effort, or standard mode at high effort. This gives developers two separate controls: the execution regime and the reasoning allocation within that regime.

The correct operating rule is:

Use the lowest reasoning level that reliably crosses the task's correctness threshold.

Maximum reasoning is not a sensible default. It can increase latency, token use, over-analysis and change scope. A model given excessive latitude may solve a broader problem than the one assigned, propose unnecessary abstractions or spend tokens exploring options that a deterministic rule could eliminate.

The Model Is Only One Part of the Runtime

The same model can behave very differently depending on where it runs. The execution surface determines what context is available, which tools can be called, what actions require approval and whether the system can inspect the consequences of its work.

OpenAI now distinguishes three user-facing modes in ChatGPT: Chat for questions and conversation, Work for longer research and finished materials, and Codex for software development and technical work. The desktop application combines all three on macOS and Windows.

GitHub Copilot adds another execution environment, placing GPT-5.6 inside the editor, Copilot CLI, GitHub cloud agents and related development surfaces.

Graph position: model selection should not be delegated entirely to an “Auto” button for high-value work. Automatic routing is useful for low-friction interaction, but production teams need their own escalation rules, cost controls and failure analysis. A vendor's router optimises its product-level objectives; it does not know the cost of an incorrect manufacturing instruction, a subtle financial-model error or an unnecessary architectural rewrite in your organisation.

What GPT-5.6 Technically Unlocks

Programmatic Tool Calling

Traditional tool calling often creates a slow orchestration loop: the model requests a tool, the host executes it, the complete result is returned, and the model chooses the next call.

GPT-5.6's Programmatic Tool Calling allows the model to write and execute lightweight programs that coordinate tools, filter intermediate data, monitor progress and choose subsequent actions.

The key technical achievement is not that the model can call more tools. It is that intermediate state can be processed without repeatedly serialising everything back into natural language.

This matters for workflows such as scanning repositories, filtering financial records, querying manufacturing capability data, processing simulation outputs and coordinating browser, terminal and document-generation steps.

Production systems should retain a trace of tool inputs, outputs, filters, decisions and validation results even when intermediate data is not returned to the model.

Persisted Reasoning

Conversation history and reasoning state are not the same. Conversation history gives the model previous visible messages. Persisted reasoning allows supported models to reuse compatible opaque reasoning items from earlier calls without exposing raw chain-of-thought text.

This can improve continuity during multi-stage repository analysis, long-running debugging, research followed by implementation and repeated revisions.

The risk is stale internal state. Applications need explicit invalidation rules, version identifiers and checkpoints rather than assuming continuity is always desirable.

Max Reasoning and Multi-Agent Ultra

Parallel agents are valuable when a problem can be decomposed into relatively independent investigations:

They are less useful when every subproblem depends tightly on one evolving state. Multi-agent execution shifts the bottleneck from exploration to synthesis.

Operational recommendation: use multiple agents for parallel discovery, adversarial review and independent validation. Use one primary agent for tightly coupled implementation unless worktree, ownership and integration boundaries are explicit.

Computer Use

OpenAI's January 2025 Operator preview introduced a Computer-Using Agent that could inspect screenshots and interact with a browser through clicks, typing and scrolling. It launched for Pro users in the United States and was later integrated into ChatGPT agent mode.

The current ChatGPT desktop stack extends computer use beyond a standalone browser. In supported regions, Work and Codex can operate approved macOS and Windows applications.

Computer use should remain a fallback rather than the foundation of a critical system. GUI automation is slower and more fragile than structured integration. It is vulnerable to layout changes, focus problems, prompt injection from visible content and accidental interaction with the wrong window.

The preferred hierarchy is:

Editable Artefact Generation

Presentation generation matters because it demonstrates that the output boundary has moved. The system is no longer limited to explaining what a deck should contain. It can increasingly own the transformation from source material to usable work product.

This is qualitatively different from chat-based drafting because the system can increasingly own the transformation from source material to a reviewable artefact.

From Agent Mode to Work Mode

Agent Mode suggested an autonomous entity that could act. Work Mode reframes the product around professional outcomes.

The shift raises the quality bar. A plausible paragraph is easy to accept. A financial workbook, software patch or manufacturing plan must survive validation.

Work systems need success criteria, provenance, observable tool traces, reversible actions, approval boundaries, deterministic tests, artefact-level review and clear ownership after handoff.

Without those controls, Work Mode risks turning a well-designed interface into a more efficient way to create review debt.

The European Rollout Gap

The rollout history matters because it reveals where AI companies perceive risk.

Operator launched only for United States-based Pro users in January 2025. Later desktop capabilities also arrived with regional restrictions. Computer Use on Windows was unavailable in the European Economic Area, United Kingdom and Switzerland at launch. Record & Replay initially excluded the European Union, United Kingdom and Switzerland as well.

The models themselves have increasingly launched globally. The action layer has often arrived later.

Technical interpretation: the intelligence and the operating permissions are becoming separate regulatory products. A model may be available in Europe while a feature that observes screens, controls applications, persists workflows or executes unattended actions remains restricted.

Organisations should not make a critical workflow dependent on one region-specific consumer surface. The durable layer should be built around APIs, approved integrations, local execution policies and substitutable components.

The Perplexity Analogy

Perplexity offers a useful comparison because its product framing makes a similar transition explicit. Perplexity describes Computer as a general-purpose digital worker that can browse, research, create, connect tools and run workflows over long periods. Comet is framed as a browser-native personal assistant for delegated web tasks.

The strategic difference is not that one product has agents and the other does not. It is how the operating model is exposed.

Perplexity begins from search and browser-native research. OpenAI begins from a general model platform, then separates conversation, knowledge work and software development into Chat, Work and Codex.

Both approaches point toward the same category: AI systems that maintain context, coordinate tools and deliver artefacts rather than merely return text.

A Practical Routing Architecture

The architecture should optimise for total successful cost, not token price alone.

Graph Technologies Evaluation Framework

Graph Technologies proposes evaluating models and agent surfaces across task success, correctness, completeness, intervention count, recovery behaviour, change discipline, validation quality, provenance, repeatability, time to usable result, expert review burden, total estimated cost and failure severity.

This is not a universal scientific equation. It is a decision model intended to make the hidden costs of weak automation visible.

Graph Technologies Case Studies

Quantitative Finance

A research workflow ingests quarterly filings, earnings transcripts and an existing forecast workbook. Luna extracts standardised line items and speaker claims. Terra reconciles the extracted data against the workbook and flags discrepancies. Sol evaluates competing explanations for margin compression, constructs scenario assumptions and produces the investment committee narrative. Work then updates the workbook and creates an editable presentation, while quantitative claims remain linked to their sources.

Defence Manufacturing and Industrial Resilience

A defence-manufacturing client receives specifications, supplier declarations, CAD exports and production constraints in incompatible formats. Luna normalises metadata and classifies components. Terra maps parts to available processes, machines and suppliers. Sol analyses production bottlenecks, substitution risks and failure scenarios across the manufacturing network. Codex reviews the software integration, while Fabrify simulates alternative production routes.

The valuable contribution is resilience engineering: better traceability, more robust supply chains, faster qualification and greater visibility across distributed manufacturing capability.

Software Engineering

A client needs to migrate a production service while preserving API compatibility. Luna inventories endpoints, configuration keys and dependency versions. Terra performs bounded refactors and updates tests. Sol examines architectural risks, identifies implicit contracts across repositories and designs the migration and rollback strategy. Codex executes tests, inspects failures and proposes minimal corrections rather than regenerating the application.

Fabrify

Fabrify, Graph Technologies' operating system for construction manufacturing, provides the clearest example of why a model hierarchy matters.

An LLM should not directly generate unverified machine commands for physical production. The safer architecture is:

The model contributes interpretation, planning and explanation. Deterministic systems retain authority over units, geometry, kinematics, machine constraints and safety-critical output.

Implementation Example: Policy-Based Routing

What Developers Should Do Now

1. Separate extraction, transformation and classification from judgement and strategy.

2. Define success criteria and mechanical validation before selecting the model.

3. Use Terra as the default for recurring engineering and professional work.

4. Route high-volume validated tasks to Luna.

5. Escalate ambiguity, difficult recovery and high-consequence decisions to Sol.

6. Select the execution surface independently from the model.

7. Measure time to usable result and expert review burden.

8. Treat GUI computer use as a fallback behind structured integrations.

9. Require explicit approval for irreversible external actions.

10. Preserve traces so model behaviour can be reviewed and improved.

Conclusion

The most important feature of GPT-5.6 is not Sol's highest benchmark score. It is that capability, reasoning budget and execution environment are becoming separable design variables.

Sol, Terra and Luna provide three levels of computational commitment. Standard and Pro modes alter how that capacity is applied. ChatGPT Work, Codex, Copilot and the Responses API place the models inside different operating environments. Programmatic Tool Calling, persisted reasoning, computer use, multi-agent execution and editable artefacts expand the distance between a prompt and a completed outcome.

That distance is where the opportunity lies—and where the risk accumulates.

The organisations that benefit most will not be those that always select the strongest model. They will be those that build the clearest routing rules, the strongest validation systems and the most disciplined boundaries between model judgement and deterministic execution.

That is the transition from using an AI assistant to engineering an AI work system.

Editorial Status

Current stage: reviewed article draft, pending final URL verification and publication QA.

Deadline: 20 July 2026.

Next actions:

• verify source URLs and product availability immediately before publication;

• run benchmark and price data through a final fact-check;

• add final diagrams and image credits;

• test the title and meta description against the two forthcoming Graph product reviews;

• publish measured Graph evaluation data as a follow-up once enough controlled runs are available.