GPT-5.6 Digital Agents: Six Control Planes Behind the Model

GPT-5.6 is easy to describe as three models plus more agent features. That summary is technically true and operationally dangerous. Sol, Terra, Luna, pro reasoning, generated tool programs, subagents, persisted reasoning, and prompt caching control different parts of a worker. Treating them as one “autonomy” setting creates a system that cannot explain why a task was expensive, why a tool ran, or who authorized the result.

A current-source check reopened six first-party OpenAI guides and verified 29 contract markers across model routing, reasoning, Programmatic Tool Calling, Multi-agent, prompt caching, and safety guidance. All six checks passed. The useful finding was not another feature list. It was an ownership map: GPT-5.6 exposes at least six independent control planes, and only one of them selects the model.

One request can cross six control planes

Consider a worker asked to inspect a repository, compare three fixes, patch one file, run tests, and prepare a production deployment. The request may use Terra for exploration, Sol in pro mode for the disputed architecture decision, a generated JavaScript program for reducing test results, several subagents for independent review, stored continuation for the long thread, and an application approval for the deployment. None of those choices implies the next.

The architecture fails when one control impersonates another. A Sol route is not permission. Pro mode is not verification. A cache hit is not task success. A subagent tree is not isolation. Programmatic calling is not approval. Those distinctions sound pedantic until the first incident; afterward, they are the only way to reconstruct what happened.

The model alias is a route, not a policy

OpenAI's current guidance says the gpt-5.6 alias routes to gpt-5.6-sol. Terra is the balanced route; Luna is the efficient, high-volume route. That naming gives an application three useful starting points, but it does not identify the right route for a real workload. A repository search with a fixed output schema and an architecture review with a costly mistake are both “coding” tasks. Their error surfaces are not comparable.

A defensible router starts from completed work. Replay accepted and rejected cases, keep the evidence that decided acceptance, and compare task success before comparing token totals. A cheaper stage that repeatedly drops a required field is not cheaper. A flagship stage used for deterministic formatting is not safer. The unit that matters is a completed outcome that survived its verifier.

Pro mode belongs on the same evaluation sheet, not on a pedestal. GPT-5.6 uses the selected model in either standard or pro mode, while reasoning effort remains independent. Pro can spend more model work before returning a single answer. It therefore needs a measured quality gain large enough to justify additional latency and billed tokens. “Hard task” is a useful hypothesis; it is not an acceptance test.

Generated JavaScript should own reductions, not consequences

Programmatic Tool Calling lets GPT-5.6 generate JavaScript that coordinates eligible tools inside a fresh isolated V8 runtime. The runtime has no Node.js, package installation, direct network access, general filesystem, subprocesses, console, or persistent JavaScript state. External reach comes through the tools exposed by the request. For client-owned functions, the application still executes the call and returns the result.

That contract fits bounded reduction: fetch several structured records, filter them, join them, calculate a result, and emit a smaller object. It also provides an explicit caller relationship. Program-issued function calls and the final program_output are separate response items, so a verifier can check both the computation and the final answer built from it.

The official guide says direct calls remain preferable when one call is enough, each result needs fresh model judgment, native citations must survive, or the action is approval-sensitive. This is not an efficiency footnote. It prevents a tool optimization from becoming an authority optimization.

A subagent tree shares the dangerous tools too

Multi-agent is available as a beta feature for GPT-5.6. A root can delegate independent work, exchange messages, wait for results, and synthesize the final response. The best shapes are concrete and separable: explore different code areas, compare documents, investigate competing failure hypotheses, or implement components that do not contend over one mutable resource.

The same documentation supplies the limiting fact: agents in the tree share the request's model and available tools. Context is separated, authority is not. If the request exposes a production deploy function, every eligible agent can potentially request it. The root remains responsible for synthesis, but synthesis cannot undo an external side effect that already ran.

That makes topology a scheduling decision. Use subagents where isolation of context improves coverage and concurrency shortens the critical path. Prefer one ordered worker when every step depends on the previous result, one slow dependency dominates, or several writers would collide. The default maximum of three concurrent subagents is a sensible capacity limit; it is not a security control.

Continuity is three different storage problems

Long-running workers need continuity, but GPT-5.6 exposes several mechanisms with different failure modes. previous_response_id continues a stored response chain. Persisted reasoning can make compatible earlier reasoning items available on later turns through reasoning.context. Prompt caching reuses exact prompt prefixes to reduce repeated processing. A single “memory enabled” flag cannot describe all three.

Stored continuation answers: which prior response does this turn extend? Persisted reasoning answers: which earlier reasoning items may influence the next sample? Prompt caching answers: which identical prefix may be reused by the service? None of them decides which business record is authoritative, how an interrupted job resumes, or whether a stale assumption should be discarded.

{
  "model": "gpt-5.6-terra",
  "previous_response_id": "resp_previous",
  "reasoning": {
    "mode": "standard",
    "effort": "medium",
    "context": "all_turns"
  },
  "max_output_tokens": 6000,
  "input": "Continue from the recorded checkpoint and return the missing evidence."
}

The request is incomplete on purpose. It names no tools, task ledger, retry key, checkpoint version, or acceptance evidence. Those belong to the application contract around the model call. Preserving reasoning does not preserve a database transaction, and a response ID is not an idempotency key.

Cache economics can reward the wrong prompt

GPT-5.6 changes the cost calculus for prompt caching. OpenAI documents cache writes at 1.25 times the uncached input rate, while cache reads remain discounted. Exact prefix matches are required. Explicit breakpoints and prompt_cache_key let the application decide which stable prefix is worth writing and reusing.

A worker with a huge, frequently changing instruction block may pay for cache writes and miss the next prefix match. A smaller stable policy followed by task-specific input is easier to measure. Track cache_write_tokens and cached_tokens beside successful outcomes. Otherwise, a dashboard can celebrate cache activity while the workflow becomes more expensive or preserves stale context.

More subtly, the cache boundary is not the trust boundary. Reusing an exact prefix proves identity of input bytes, not freshness of linked records, correctness of tool output, or authorization for a later action. Cache stable instructions and reviewed reference material; fetch volatile state through a source that can report version and retrieval time.

Validation: the evidence packet must outlive the prose

A digital worker's final paragraph is a view, not the durable record. The application should retain enough information to recompute or challenge the decision: declared inputs, selected route and reasoning settings, tool-call relationships, exact output schemas, source versions, retries, validation results, and any held external action.

The current documentation check is a deliberately narrow example. It fetched six official pages, required 29 exact markers, recorded response status, content type, byte count, and SHA-256, and passed all six source contracts. That artifact supports the control-plane map in this article. It does not benchmark any GPT-5.6 model, invoke hosted Programmatic Tool Calling, run the beta Multi-agent API, measure latency, or estimate production cost.

That limitation is useful. Evidence should be strong enough for the claim and no stronger. A source check can establish an API contract. Only representative model calls can establish route quality. Only an authorized runtime exercise can establish tool containment. Only a guarded dry run can establish that an approval packet binds the intended external action.

Approval belongs to the effect, never the tier

Sol does not earn broader credentials. Luna does not become harmless because it is cheaper. A model can prepare a deployment plan, but the application must bind authorization to the exact repository, revision, environment, command, and expiry. A customer message needs its exact audience and body. A purchase needs its exact item, seller, price, and limit.

OpenAI's safety guidance recommends adversarial testing and human review for consequential uses, especially when generated code or high-stakes output will be used in practice. It also says reviewers need access to the underlying evidence. That requirement rules out a vague “approve agent action” button. The reviewer must see the proposed effect and the record needed to verify it.

• Local reversible work: allow declared reads, task-owned artifacts, and bounded checks without turning every safe step into a permission dialog.
• Tool reduction: expose only eligible tools, require a fixed result schema, cap retries, and preserve caller relationships.
• Parallel exploration: separate workstreams, limit concurrency, reconcile conflicts, and keep shared writes behind one owner.
• External consequence: render the exact action packet, hold it, and require an application-visible decision tied to that packet.

A minimal worker manifest exposes the seams

The point of a manifest is not to turn product policy into decorative YAML. It should make accidental coupling reviewable. One compact record can name the capability route, reasoning budget, tool caller, topology, continuity, evidence, and consequence gate for each stage.

stages:
  inspect:
    model: gpt-5.6-terra
    reasoning: { mode: standard, effort: medium }
    tools: direct
    topology: single
    evidence: [repository_revision, findings]

  compare:
    model: gpt-5.6-sol
    reasoning: { mode: pro, effort: high }
    tools: direct
    topology: { kind: multi_agent, max_concurrent: 3 }
    evidence: [alternatives, citations, dissent]

  reduce_test_results:
    model: gpt-5.6-luna
    tools: programmatic
    output_schema: test_summary_v2
    retries: 1

  deploy:
    route: human
    approval: exact_action_packet
    idempotency_key: required

This example is a design record, not a recommended universal allocation. The model routes must move when replay data says they should. Programmatic calling should disappear from a stage whose control flow becomes semantic. Multi-agent should collapse when workers contend over state. The external gate should remain even when model quality improves.

Failure modes during a GPT-5.6 migration

Before changing an existing worker to GPT-5.6, inventory its actual stages and effects. Mark which outputs are locally reversible, which tools mutate shared state, which evidence proves completion, and which actions need a person. Then replay representative work with the existing route and one proposed route at the same reasoning setting. OpenAI's migration guidance recommends comparing the current setting with the same setting and one level lower; the application's acceptance evidence should decide the winner.

Only after route quality is stable should a team introduce generated tool programs or a subagent tree. Each adds a new state machine. Add one, retain the caller or agent ledger, and rehearse failure: missing tool output, partial program result, conflicting subagent findings, interrupted continuation, cache miss, expired approval, repeated delivery. Recovery behavior is part of the product, not cleanup after the demo.

The source record behind this architecture

• OpenAI: Using GPT-5.6 — Sol, Terra, Luna, migration guidance, pro mode, Programmatic Tool Calling, Multi-agent, persisted reasoning, and caching controls.
• OpenAI: Programmatic Tool Calling — hosted V8 boundaries, eligible callers, response item relationships, and direct-versus-programmatic task shapes.
• OpenAI: Multi-agent — beta status, shared model and tools, collaboration actions, concurrency, and shared-state trade-offs.
• OpenAI: Reasoning models — reasoning mode, effort, token limits, continuation, and persisted reasoning.
• OpenAI: Prompt caching — exact prefix matching, GPT-5.6 cache-write pricing, cache keys, and explicit breakpoints.
• OpenAI: Safety best practices — adversarial testing, human review, underlying evidence, and privacy-preserving safety identifiers.