# GPT-6

Move an app from GPT-5.6 to GPT-6: pick one of three tiers, check the effort, and drop the sampling fields.

1. [Change the model ID](#1-change-the-model-id).
2. [Update the request](#2-update-the-request).
3. [Read the answer](#3-read-the-answer).
4. [Set the effort](#4-set-the-effort).
5. [Compare before you switch](#5-compare-before-you-switch).

## 1. Change the model ID

GPT-6 comes as three tiers, each with a `-pro` ID: the same model, served with pro reasoning, which works longer before one final answer. There is no Terra in GPT-6.

| Model ID | For | Effort levels |
|---|---|---|
| `openai/gpt-6-astra` | the most capable: long, many-step work across code and documents | `low` to `max`; always reasons |
| `openai/gpt-6-astra-pro` | Astra, with pro reasoning | `low` to `max`; always reasons |
| `openai/gpt-6-sol` | strong reasoning on demanding work | `none` to `max` |
| `openai/gpt-6-sol-pro` | Sol, with pro reasoning | `none` to `max` |
| `openai/gpt-6-luna` | efficient, repeated work at scale | `none` to `max` |
| `openai/gpt-6-luna-pro` | Luna, with pro reasoning | `none` to `max` |

| | From | To |
|---|---|---|
| Model ID | `openai/gpt-5.6-sol`, `-terra` or `-luna` | one of the six above |
| Context | 1 050 000 tokens | 1 050 000 tokens |
| Longest answer | 128 000 tokens | 128 000 tokens |

Each ID also exists with `:batch` at its end, for batch work. [`GET /v1/model/{lab}/{model}`](/docs/reference/model) answers each model's entry, `reasoning` included. The request keeps its shape; `model` changes.

```json
{
  "model": "openai/gpt-6-sol",
  "reasoning": {
    "effort": "medium"
  },
  "messages": [
    {
      "role": "user",
      "content": "Summarise the incident report in five lines."
    }
  ]
}
```

## 2. Update the request

| You send today | On GPT-6 | Send instead |
|---|---|---|
| effort `none` on Astra | refused | `low` |
| effort `minimal` | not among the levels | `low`, then compare |
| `temperature`, `top_p`, `logprobs` or `top_logprobs` | OpenAI takes them at effort `none` only | nothing: steer with the prompt |
| `prompt_cache_retention` | replaced | `prompt_cache_options: {"ttl": "30m"}` |

<div class="watch-out">
<p>On OpenAI's own API, GPT-6 Astra calls tools on the Responses shape only, and Sol and Luna call functions on the chat shape at effort <code>none</code> only. Run your tool calls on <code>/v1/chat/completions</code> before you switch: see <a href="/docs/tools">Tools and function calling</a>.</p>
</div>

One addition changes the effort from one turn onward, and keeps the start of the conversation as it was, so a cached prompt stays cached. Put a `system` message with empty `content` and a `configuration_update` just before the user turn it applies to.

```json
{
  "model": "openai/gpt-6-sol",
  "reasoning": {
    "effort": "medium"
  },
  "messages": [
    {
      "role": "user",
      "content": "Summarise the incident report."
    },
    {
      "role": "assistant",
      "content": "The outage began at 09:14 when …"
    },
    {
      "role": "system",
      "content": "",
      "configuration_update": {
        "reasoning": {
          "effort": "high"
        }
      }
    },
    {
      "role": "user",
      "content": "Now find the root cause and propose a fix."
    }
  ]
}
```

| Rule | Why |
|---|---|
| keep each update where it was when you send the history back | a moved update changes the start, and the cache is lost |
| never two updates side by side | refused |
| never on a `-pro` ID | refused |

## 3. Read the answer

OpenAI can stop a GPT-6 answer on biology or cybersecurity grounds. It comes back as a 403 whose body says the model refused, sometimes after the answer began. Show the message; sending the same prompt again returns the same refusal. See [Errors and retries](/docs/errors-and-retries).

OpenAI lists three ways Astra behaves differently: it asks more questions before it acts, follows instructions in long files more closely, and formats answers with more lists and tables. Say in the system prompt how much it may do without asking, and the style you want.

On `/v1/responses`, a tool can be marked `"async": true`: the model calls it and goes on working, and you send its result in a later request, with the same `call_id`.

## 4. Set the effort

| Route | Field |
|---|---|
| `/v1/chat/completions` | `reasoning.effort`, or `reasoning_effort` |

Keep the level you ran on GPT-5.6 as the starting point, and set it in every request. Move Astra off `none`. Keep the request's level fixed for the whole conversation, and change it for one stretch with a `configuration_update`.

## 5. Compare before you switch

Send the same set of real prompts to both IDs, and compare three things.

| Compare | Where |
|---|---|
| the answers | your own check: a test suite, a reviewer, the task's pass rate |
| what each cost | `usage.cost`, in DA, on every answer |
| how much each reasoned | `usage.completion_tokens_details.reasoning_tokens` |

GPT-6 comes as tiers, and each tier has its own lowest effort, so the comparison is a sweep with an effort per tier. The script sends one task to the old ID and to each tier, and one more run puts Astra at `none` to show the refusal. It prints one line per run: how the answer ended, what the model reasoned, and the charge in DA, then the first words of the answer. A refused request prints its status; show a refusal as it is, because sending the same prompt again returns it again.

| Run | Model | Effort |
|---|---|---|
| `from` | `MODEL` | `EFFORT` |
| `astra` | `ASTRA` | `low` |
| `astra, none` | `ASTRA` | `none` |
| `sol` | `SOL` | `none` |
| `luna` | `LUNA` | `none` |

```python
import os
from openai import APIStatusError, OpenAI

API_KEY = os.environ["OPENDUNES_API_KEY"]
BASE_URL = "https://opendunes.com/v1"
MODEL = "anthropic/claude-sonnet-4.5"
ASTRA = "anthropic/claude-sonnet-4.5"
SOL = "anthropic/claude-sonnet-4.5"
LUNA = "anthropic/claude-sonnet-4.5"
EFFORT = "medium"
MAX_TOKENS = 8000
TASK = (
    "Summarise the incident report in five lines.\n\n"
    "The outage began at 09:14 when the payment queue filled. "
    "The team restarted the worker at 09:40. Orders placed in "
    "between were retried. No card was charged twice."
)
RUNS = [
    ("from", MODEL, EFFORT),
    ("astra", ASTRA, "low"),
    ("astra, none", ASTRA, "none"),
    ("sol", SOL, "none"),
    ("luna", LUNA, "none"),
]

client = OpenAI(base_url=BASE_URL, api_key=API_KEY)

for label, model, effort in RUNS:
    try:
        reply = client.chat.completions.create(
            model=model,
            max_tokens=MAX_TOKENS,
            messages=[{"role": "user", "content": TASK}],
            extra_body={"reasoning": {"effort": effort}},
        )
    except APIStatusError as error:
        print(f"{label:12} refused, status {error.status_code}")
        continue
    usage = reply.usage
    details = usage.completion_tokens_details
    thought = details.reasoning_tokens if details else 0
    print(
        f"{label:12} {reply.choices[0].finish_reason:7}",
        f"thought {thought}",
        f"cost {usage.cost}",
    )
    print("   ", (reply.choices[0].message.content or "")[:60])
```

```javascript
import OpenAI from "openai";

const API_KEY = process.env.OPENDUNES_API_KEY;
const BASE_URL = "https://opendunes.com/v1";
const MODEL = "anthropic/claude-sonnet-4.5";
const ASTRA = "anthropic/claude-sonnet-4.5";
const SOL = "anthropic/claude-sonnet-4.5";
const LUNA = "anthropic/claude-sonnet-4.5";
const EFFORT = "medium";
const MAX_TOKENS = 8000;
const TASK =
  "Summarise the incident report in five lines.\n\n" +
  "The outage began at 09:14 when the payment queue filled. " +
  "The team restarted the worker at 09:40. Orders placed in " +
  "between were retried. No card was charged twice.";
const RUNS = [
  ["from", MODEL, EFFORT],
  ["astra", ASTRA, "low"],
  ["astra, none", ASTRA, "none"],
  ["sol", SOL, "none"],
  ["luna", LUNA, "none"],
];

const client = new OpenAI({ baseURL: BASE_URL, apiKey: API_KEY });

for (const [label, model, effort] of RUNS) {
  let reply;
  try {
    reply = await client.chat.completions.create({
      model,
      max_tokens: MAX_TOKENS,
      messages: [{ role: "user", content: TASK }],
      reasoning: { effort },
    });
  } catch (error) {
    if (!(error instanceof OpenAI.APIError)) throw error;
    console.log(label.padEnd(12), "refused, status", error.status);
    continue;
  }
  const { usage, choices } = reply;
  const thought = usage.completion_tokens_details?.reasoning_tokens ?? 0;
  console.log(
    label.padEnd(12),
    choices[0].finish_reason.padEnd(7),
    `thought ${thought}`,
    `cost ${usage.cost}`,
  );
  console.log("   ", (choices[0].message.content ?? "").slice(0, 60));
}
```

```go
package main

import (
	"context"
	"errors"
	"fmt"
	"os"
	"strconv"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
)

const (
	baseURL   = "https://opendunes.com/v1"
	model     = "anthropic/claude-sonnet-4.5"
	astra     = "anthropic/claude-sonnet-4.5"
	sol       = "anthropic/claude-sonnet-4.5"
	luna      = "anthropic/claude-sonnet-4.5"
	effort    = "medium"
	maxTokens = 8000
	task      = "Summarise the incident report in five lines.\n\n" +
		"The outage began at 09:14 when the payment queue filled. " +
		"The team restarted the worker at 09:40. Orders placed in " +
		"between were retried. No card was charged twice."
)

type run struct {
	label  string
	model  string
	effort string
}

func main() {
	apiKey := os.Getenv("OPENDUNES_API_KEY")

	runs := []run{
		{"from", model, effort},
		{"astra", astra, "low"},
		{"astra, none", astra, "none"},
		{"sol", sol, "none"},
		{"luna", luna, "none"},
	}

	client := openai.NewClient(
		option.WithBaseURL(baseURL),
		option.WithAPIKey(apiKey),
	)
	for _, r := range runs {
		params := openai.ChatCompletionNewParams{
			Model:     openai.ChatModel(r.model),
			MaxTokens: openai.Int(maxTokens),
			Messages: []openai.ChatCompletionMessageParamUnion{
				openai.UserMessage(task),
			},
		}
		params.SetExtraFields(map[string]any{
			"reasoning": map[string]any{"effort": r.effort},
		})
		reply, err := client.Chat.Completions.New(context.TODO(), params)
		var apiErr *openai.Error
		if errors.As(err, &apiErr) {
			fmt.Printf("%-12s refused, status %d\n", r.label, apiErr.StatusCode)
			continue
		}
		if err != nil {
			panic(err)
		}
		choice := reply.Choices[0]
		fmt.Printf("%-12s %-7s thought %d cost %v\n",
			r.label, choice.FinishReason,
			reply.Usage.CompletionTokensDetails.ReasoningTokens,
			charge(reply))
		fmt.Printf("    %.60s\n", choice.Message.Content)
	}
}

func charge(reply *openai.ChatCompletion) float64 {
	cost := reply.Usage.JSON.ExtraFields["cost"].Raw()
	value, _ := strconv.ParseFloat(cost, 64)
	return value
}
```

```bash cURL
ADDRESS="https://opendunes.com/v1/chat/completions"
MODEL="anthropic/claude-sonnet-4.5"
ASTRA="anthropic/claude-sonnet-4.5"
SOL="anthropic/claude-sonnet-4.5"
LUNA="anthropic/claude-sonnet-4.5"
EFFORT="medium"
TASK="Summarise the incident report in five lines. \
The outage began at 09:14 when the payment queue filled. \
The team restarted the worker at 09:40. Orders placed in between \
were retried. No card was charged twice."

run() {
  jq -n --arg model "$2" --arg task "$TASK" --arg effort "$3" \
    '{model: $model, max_tokens: 8000,
      reasoning: {effort: $effort},
      messages: [{role: "user", content: $task}]}' |
    curl -s "$ADDRESS" \
      -H "Authorization: Bearer $OPENDUNES_API_KEY" \
      -H "Content-Type: application/json" \
      -d @- |
    jq -c --arg label "$1" '{label: $label,
      finish: .choices[0].finish_reason,
      thought: .usage.completion_tokens_details.reasoning_tokens,
      cost: .usage.cost,
      answer: ((.choices[0].message.content // "") | .[:60]),
      refused: .error.message}'
}

run "from" "$MODEL" "$EFFORT"
run "astra" "$ASTRA" "low"
run "astra, none" "$ASTRA" "none"
run "sol" "$SOL" "none"
run "luna" "$LUNA" "none"
```

The samples put `anthropic/claude-sonnet-4.5` in every seat, so they run as they stand. Set `MODEL` to `openai/gpt-5.6-sol`, `-terra` or `-luna`, and the others to the IDs below.

| Seat | Model ID |
|---|---|
| `ASTRA` | `openai/gpt-6-astra` |
| `SOL` | `openai/gpt-6-sol` |
| `LUNA` | `openai/gpt-6-luna` |

With the GPT-6 IDs set, the line `astra, none` comes back refused, and the other tiers answer. Read the three tiers against your own check, and keep the effort you ran on GPT-5.6 as the first level to try on each.

Switch once the new ID holds; going back is the same one-line change. Run your red-team suite on the new ID too: [Red teaming](/docs/cookbook/red-teaming).
