Documentation — Spybara

deprecations.md +1 −1

Details

282 282

283### 2025-09-26: Legacy GPT model snapshots283### 2025-09-26: Legacy GPT model snapshots

284 284

285To improve reliability and make it easier for developers to choose the right models, we are deprecating a set of older OpenAI models with declining usage over the next six to twelve months. Access to these models will be shut down on the dates below.285To improve reliability and make it easier for developers to choose the right models, we deprecated a set of older OpenAI models with declining usage. Access to these models was shut down on September 28, 2026.

286 286

288| ------------- | ------------------------ | ----------------------- |288| ------------- | ------------------------ | ----------------------- |

guides/admin-apis.md +1 −1

Details

183 notification_channel: {183 notification_channel: {

184 recipients: ["billing@example.com"],184 recipients: ["billing@example.com"],

185 type: "email",185 type: "email",

186 subject_prefix: "[OpenAI spend]",186 subject_prefix: "OpenAI spend",

187 },187 },

188 threshold_amount: 50000,188 threshold_amount: 50000,

189 }189 }

guides/agents-api/observability.md +31 −11

Details

268Identify delegated command execution268Identify delegated command execution

269 269

270```javascript270```javascript

271// Replace the illustrative IDs and URLs below with your own resource values.271// Replace the illustrative session and turn IDs with values from your command item.

272import OpenAI from "openai";272import OpenAI from "openai";

273const client = new OpenAI();273const client = new OpenAI();

274 274

275const sessionId = "sess_123";275async function findTurn(sessionId, turnId) {

276const turns = await client.beta.agents.sessions.turns.list(sessionId, {276 for await (const turn of client.beta.agents.sessions.turns.list(sessionId, {

277 limit: 20,277 limit: 100,

278 order: "desc",278 })) {

279});279 if (turn.id === turnId) {

280console.log(turns.data);280 return client.beta.agents.sessions.turns.retrieve(turnId, {

281const turnId = "turn_123";

282const turn = await client.beta.agents.sessions.turns.retrieve(turnId, {

283 session_id: sessionId,281 session_id: sessionId,

284});282 });

285console.log(turn.subagent_id);283 }

284 }

285 for await (const subagent of client.beta.agents.sessions.subagents.list(

286 sessionId,

287 { limit: 100 }

288 )) {

289 for await (const turn of client.beta.agents.sessions.subagents.turns.list(

290 subagent.id,

291 { session_id: sessionId, limit: 100 }

292 )) {

293 if (turn.id === turnId) {

294 return client.beta.agents.sessions.subagents.turns.retrieve(turnId, {

295 session_id: sessionId,

296 subagent_id: subagent.id,

297 });

298 }

299 }

300 }

301 throw new Error(`Turn ${turnId} not found in session ${sessionId}`);

302}

303

304const turn = await findTurn("sess_123", "turn_123");

305console.log(turn.subagent_id || "main agent");

286```306```

287 307

288```python308```python

guides/agents-api/tools/computer-use.md +11 −6

Details

303```303```

304 304

305```javascript305```javascript

306import promptSync from "prompt-sync";306import { createInterface } from "node:readline";

307 307

308const prompt = promptSync({ sigint: true });308const inputLines = createInterface({

309 input: process.stdin,

310 crlfDelay: Infinity,

311});

312const answers = inputLines[Symbol.asyncIterator]();

309 313

310/** @param {OpenAI} client */314/** @param {OpenAI} client */

311async function respondToOriginApproval(client, sessionId, approval) {315async function respondToOriginApproval(client, sessionId, approval) {

315 console.log(request.reason ?? "The browser needs access to this origin.");319 console.log(request.reason ?? "The browser needs access to this origin.");

316 let input;320 let input;

317 do {321 do {

318 input =322 process.stdout.write(

319 prompt("Allow access? [approve/deny/cancel, default deny] ")323 "Allow access? [approve/deny/cancel, default deny] "

320 .trim()324 );

321 .toLowerCase() || "deny";325 const answer = await answers.next();

326 input = (answer.done ? "" : answer.value).trim().toLowerCase() || "deny";

322 } while (!["approve", "deny", "cancel"].includes(input));327 } while (!["approve", "deny", "cancel"].includes(input));

323 const decision =328 const decision =

324 input === "approve" ? "approve" : input === "cancel" ? "cancel" : "deny";329 input === "approve" ? "approve" : input === "cancel" ? "cancel" : "deny";

guides/audio-chat-completions.md +1 −1

Details

238 ],238 ],

239 },239 },

240 ],240 ],

241 store: true,241 store: false,

242});242});

243 243

244console.log(response.choices[0]);244console.log(response.choices[0]);

guides/background.md +9 −3

Details

438});438});

439 439

440let cursor = null;440let cursor = null;

441let responseId = null;

441for await (const event of stream) {442for await (const event of stream) {

442 console.log(event);443 console.log(event);

443 cursor = event.sequence_number;444 // Keepalives use connection counters, not stored-event resume positions.

445 if (String(event.type) !== "keepalive") cursor = event.sequence_number;

446 if ("response" in event && event.response?.id) responseId = event.response.id;

444}447}

445 448

446// If the connection drops, you can resume streaming from the last cursor (SDK support coming soon):449// If the connection drops, resume streaming from the last stored-event cursor:

447// const resumedStream = await client.responses.stream(resp.id, { starting_after: cursor });450// const resumedStream = await client.responses.retrieve(responseId, {

451// stream: true,

452// starting_after: cursor,

453// });

448// for await (const event of resumedStream) { ... }454// for await (const event of resumedStream) { ... }

449```455```

450 456

guides/compaction.md +22 −4

Details

55```javascript55```javascript

56import OpenAI from "openai";56import OpenAI from "openai";

57import { toResponseInputItems } from "openai/lib/responses/ResponseInputItems";57import { toResponseInputItems } from "openai/lib/responses/ResponseInputItems";

58import { createInterface } from "node:readline";

58 59

59const client = new OpenAI();60const client = new OpenAI();

60 61

66 },67 },

67];68];

68 69

~~69const response = await client.responses.create({~~70// Subscribe before generation so piped follow-up turns are not lost.

71const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });

72const turns = lines[Symbol.asyncIterator]();

74async function respond() {

75 const response = await client.responses.create({

70 model: "gpt-5.3-codex",76 model: "gpt-5.3-codex",

71 input: conversation,77 input: conversation,

72 store: false,78 store: false,

73 context_management: [{ type: "compaction", compact_threshold: 200_000 }],79 context_management: [{ type: "compaction", compact_threshold: 200_000 }],

~~74});~~80 });

75 81

~~76conversation.push(...toResponseInputItems(response.output));~~82 conversation.push(...toResponseInputItems(response.output));

~~77console.log(response.output_text);~~83 console.log(response.output_text);

84}

86try {

87 await respond();

88 for await (const line of turns) {

89 if (!line.trim()) continue;

90 conversation.push({ type: "message", role: "user", content: line });

91 await respond();

92 }

93} finally {

94 lines.close();

95}

78```96```

79 97

80```python98```python

guides/completions.md +9 −8

Details

2 2

3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

4 4

~~5`gpt-3.5-turbo-instruct`, `babbage-002`, and `davinci-002` have a scheduled~~5`gpt-3.5-turbo-instruct`, `babbage-002`, and `davinci-002` were shut down on

~~6 shutdown date of September 28, 2026. The examples below retain the legacy~~6 [September 28,

~~7 request format for reference. The documented replacement, `gpt-5.6-terra`,~~7 2026](https://developers.openai.com/api/docs/deprecations#2025-09-26-legacy-gpt-model-snapshots).

~~8 requires migration to the [Responses~~8 Fine-tuned versions of `babbage-002` and `davinci-002` were shut down on

~~9 API](https://developers.openai.com/api/docs/guides/migrate-to-responses) or Chat Completions; it~~9 [October 23,

~~10 is not a drop-in model replacement for the legacy Completions endpoint. See~~10 2026](https://developers.openai.com/api/docs/deprecations#2026-04-22-legacy-gpt-model-snapshots). The

~~11 the [deprecation~~11 examples below show the legacy `/v1/completions` request format for reference.

~~12 notice](https://developers.openai.com/api/docs/deprecations#2025-09-26-legacy-gpt-model-snapshots).~~12 To use current models, migrate your requests to the [Responses

13 API](https://developers.openai.com/api/docs/guides/migrate-to-responses) or Chat Completions.

13 14

14The completions API endpoint received its final update in July 2023 and has a different interface than the new Chat Completions endpoint. Instead of the input being a list of messages, the input is a freeform text string called a `prompt`.15The completions API endpoint received its final update in July 2023 and has a different interface than the new Chat Completions endpoint. Instead of the input being a list of messages, the input is a freeform text string called a `prompt`.

15 16

guides/fast-mode.md +1 −1

Details

178 178

179### Is Fast mode compatible with data residency, Zero Data Retention, and a BAA?179### Is Fast mode compatible with data residency, Zero Data Retention, and a BAA?

180 180

181Fast mode is compatible with data residency, Zero Data Retention, and a Business Associate Agreement (BAA), subject to model-specific availability. Fast mode supports EU data residency for GPT-6.1 Sol and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. Existing endpoint, tool, eligibility, and contractual requirements still apply. See the [Your data guide](https://developers.openai.com/api/docs/guides/your-data) for details.181Fast mode is compatible with data residency, Zero Data Retention, and a Business Associate Agreement (BAA), subject to model-specific availability. Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. Existing endpoint, tool, eligibility, and contractual requirements still apply. See the [Your data guide](https://developers.openai.com/api/docs/guides/your-data) for details.

guides/function-calling.md +1 −0

Details

1237 model: "gpt-6-astra",1237 model: "gpt-6-astra",

1238 input: [{ role: "user", content: "What's the weather like in Paris today?" }],1238 input: [{ role: "user", content: "What's the weather like in Paris today?" }],

1239 tools,1239 tools,

1240 tool_choice: "required",

1240 stream: true,1241 stream: true,

1241 store: true,1242 store: true,

1242});1243});

guides/latest-model.md +37 −19

Details

9 9

10> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.10> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

11 11

~~12Choose a GPT-6 model based on the reasoning your task requires, speed, and cost.~~

16- [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra)12- [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra)

17 13

18 **Highest intelligence**14 **Highest intelligence**

25 21

26 Near-Astra performance for complex work at a lower cost.22 Near-Astra performance for complex work at a lower cost.

27 23

24- [GPT-6.1 Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra)

26 **Fast and efficient**

28 For visual reasoning, precise computer use, and clear, natural writing.

28- [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna)30- [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna)

29 31

30 **Fastest and most cost-effective**32 **Fastest and most cost-effective**

48 50

49### GPT-6.1 Sol51### GPT-6.1 Sol

50 52

~~51Use GPT-6.1 Sol for complex coding, computer use, and professional work when you~~53GPT-6.1 Sol delivers near-Astra performance at a lower cost for complex coding,

~~52want near-Astra performance at a lower cost. Compare it with Astra on your tasks~~54computer use, and professional work. It supports `low`, `medium` (default),

~~53to assess the tradeoff between quality and cost.~~55`high`, `xhigh`, and `max` reasoning effort.

57See the [model page](https://developers.openai.com/api/docs/models/gpt-6.1-sol) for specifications and pricing.

59<a id="gpt-61-terra"></a>

60<a id="gpt-6.1-terra"></a>

62### GPT-6.1 Terra

64GPT-6.1 Terra is a fast, efficient model for visual reasoning, precise computer

65use, and clear, natural writing. Use it to match product photos to catalog

66entries, compare technical drawings, act on application screens, or draft and

67revise text.

69It supports `none`, `low`, `medium` (default), `high`, `xhigh`, and `max`

70reasoning effort. Start with `medium` and increase it if the improvement in

71quality is worth the added time and tokens.

54 72

~~55Set `reasoning.effort` to `low`, `medium` (default), `high`, `xhigh`, or `max`.~~73When migrating from GPT-5.6 Terra, compare both models on representative images

~~56Use the Responses API for tool calling. Chat Completions supports requests~~74and workflows using the same reasoning effort. If your application calls tools

~~57without tools. The `none` and `minimal` reasoning efforts are not supported.~~75through Chat Completions, migrate those requests to the Responses API.

58 76

~~59See the [model page](https://developers.openai.com/api/docs/models/gpt-6.1-sol) for specifications,~~77See the [model page](https://developers.openai.com/api/docs/models/gpt-6.1-terra) for specifications and pricing,

~~60pricing, and availability, or [model selection](https://developers.openai.com/api/docs/guides/model-selection#when-to-consider-gpt-61-sol)~~78[image inputs](https://developers.openai.com/api/docs/guides/images-vision) for visual analysis, and

~~61for guidance on choosing a model.~~79[computer use](https://developers.openai.com/api/docs/guides/tools-computer-use) for acting on screens.

62 80

63<a id="gpt-6-astra-what-is-new" className="scroll-mt-[110px]"></a>81<a id="gpt-6-astra-what-is-new" className="scroll-mt-[110px]"></a>

64 82

73 91

74## Limitations92## Limitations

75 93

~~76- GPT-6 Astra and GPT-6.1 Sol do not support the `none` reasoning effort; GPT-6 Sol and GPT-6 Luna do.~~94- GPT-6 Astra and GPT-6.1 Sol do not support the `none` reasoning effort; GPT-6.1 Terra, GPT-6 Sol, and GPT-6 Luna do.

77- Fast mode supports EU data residency for GPT-6.1 Sol and GPT-6 Luna, but not GPT-6 Astra or GPT-6 Sol. [Ultrafast mode](https://developers.openai.com/api/docs/guides/ultrafast-mode) for GPT-6.1 Sol supports US and EU data residency and global processing. GPT-6 Astra Ultrafast supports US data residency and global processing only. See [data residency eligibility](https://developers.openai.com/api/docs/guides/your-data#which-models-and-features-are-eligible-for-data-residency).95- Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna, but not GPT-6 Astra or GPT-6 Sol. [Ultrafast mode](https://developers.openai.com/api/docs/guides/ultrafast-mode) for GPT-6.1 Sol supports US and EU data residency and global processing. GPT-6 Astra Ultrafast supports US data residency and global processing only. See [data residency eligibility](https://developers.openai.com/api/docs/guides/your-data#which-models-and-features-are-eligible-for-data-residency).

78 96

79<a id="prompting-best-practices" className="scroll-mt-[110px]"></a>97<a id="prompting-best-practices" className="scroll-mt-[110px]"></a>

80 98

198 216

199### Update API and model parameters217### Update API and model parameters

200 218

201Set `model` to `gpt-6-astra`, `gpt-6.1-sol`, or `gpt-6-luna`, then check the following:219Set `model` to `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6.1-terra`, or `gpt-6-luna`, then check the following:

202 220

203- **Reasoning effort:** Preserve your current effective [reasoning effort](https://developers.openai.com/api/docs/guides/reasoning#reasoning-effort) where supported. GPT-6 Astra and GPT-6.1 Sol do not support `none`; use `low` instead. GPT-6 Sol and GPT-6 Luna support `none`. If your existing request uses `minimal`, start with `low` and compare results on representative tasks. Use `reasoning.effort` in Responses or `reasoning_effort` in Chat Completions.221- **Reasoning effort:** Preserve your current effective [reasoning effort](https://developers.openai.com/api/docs/guides/reasoning#reasoning-effort) where supported. GPT-6 Astra and GPT-6.1 Sol do not support `none`; use `low` instead. GPT-6.1 Terra, GPT-6 Sol, and GPT-6 Luna support `none`. If your existing request uses `minimal`, start with `low` and compare results on representative tasks. Use `reasoning.effort` in Responses or `reasoning_effort` in Chat Completions.

204- **Tool calling:** Use the [Responses API](https://developers.openai.com/api/docs/guides/migrate-to-responses#migrating-from-chat-completions). GPT-6 Astra and GPT-6.1 Sol support Chat Completions, but tool calling requires Responses. GPT-6 Sol and GPT-6 Luna support function calling in Chat Completions only with `reasoning_effort: "none"`. Use Responses for reasoning with tools.222- **Tool calling:** Use the [Responses API](https://developers.openai.com/api/docs/guides/migrate-to-responses#migrating-from-chat-completions). GPT-6 Astra, GPT-6.1 Sol, and GPT-6.1 Terra support Chat Completions, but tool calling requires Responses. GPT-6 Sol and GPT-6 Luna support function calling in Chat Completions only with `reasoning_effort: "none"`. Use Responses for reasoning with tools.

205- **Unsupported parameters:** When reasoning effort is not `none`, remove `temperature`, `top_p`, and `top_logprobs`. For Chat Completions, also remove `logprobs`. For Responses, remove `message.output_text.logprobs` from `include`.223- **Unsupported parameters:** When reasoning effort is not `none`, remove `temperature`, `top_p`, and `top_logprobs`. For Chat Completions, also remove `logprobs`. For Responses, remove `message.output_text.logprobs` from `include`.

206- **Data residency:** Fast mode supports EU data residency for GPT-6.1 Sol and GPT-6 Luna, but not GPT-6 Astra or GPT-6 Sol. [Ultrafast mode](https://developers.openai.com/api/docs/guides/ultrafast-mode) for GPT-6.1 Sol supports US and EU data residency and global processing. GPT-6 Astra Ultrafast supports US data residency and global processing only. Fast mode for GPT-6 Astra does not include a latency SLA. See [Fast mode compatibility](https://developers.openai.com/api/docs/guides/fast-mode#is-fast-mode-compatible-with-data-residency-zero-data-retention-and-a-baa).224- **Data residency:** Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna, but not GPT-6 Astra or GPT-6 Sol. [Ultrafast mode](https://developers.openai.com/api/docs/guides/ultrafast-mode) for GPT-6.1 Sol supports US and EU data residency and global processing. GPT-6 Astra Ultrafast supports US data residency and global processing only. Fast mode for GPT-6 Astra does not include a latency SLA. See [Fast mode compatibility](https://developers.openai.com/api/docs/guides/fast-mode#is-fast-mode-compatible-with-data-residency-zero-data-retention-and-a-baa).

207- **Changing reasoning effort:** If your application changes effort between responses, use `configuration_update` items in standard, single-agent requests. Keep request-level `reasoning.effort` unchanged to preserve the prompt prefix for caching. Check the [compatibility limits](https://developers.openai.com/api/docs/guides/reasoning#change-reasoning-mid-conversation) before adopting this feature.225- **Changing reasoning effort:** If your application changes effort between responses, use `configuration_update` items in standard, single-agent requests. Keep request-level `reasoning.effort` unchanged to preserve the prompt prefix for caching. Check the [compatibility limits](https://developers.openai.com/api/docs/guides/reasoning#change-reasoning-mid-conversation) before adopting this feature.

208- **Prompt caching:** When migrating from GPT-5.5 or earlier, replace `prompt_cache_retention` with `prompt_cache_options.ttl` set to `"30m"`. Review the [prompt caching changes](https://developers.openai.com/api/docs/guides/prompt-caching#summary-of-model-differences), including cache boundaries and cache-write billing.226- **Prompt caching:** When migrating from GPT-5.5 or earlier, replace `prompt_cache_retention` with `prompt_cache_options.ttl` set to `"30m"`. Review the [prompt caching changes](https://developers.openai.com/api/docs/guides/prompt-caching#summary-of-model-differences), including cache boundaries and cache-write billing.

209- **Unnecessary approval pauses:** If you run into issues where the model keeps asking for approval before proceeding, use the [initiative and follow-through guidance](#initiative-and-follow-through) to prompt for more autonomous execution. See the rest of [Prompting best practices](#prompting-best-practices) for guidance on instruction following, writing style, subagent delegation, and testing.227- **Unnecessary approval pauses:** If you run into issues where the model keeps asking for approval before proceeding, use the [initiative and follow-through guidance](#initiative-and-follow-through) to prompt for more autonomous execution. See the rest of [Prompting best practices](#prompting-best-practices) for guidance on instruction following, writing style, subagent delegation, and testing.

guides/live-delegation.md +33 −1

Details

313 313

314Use `session.commentary.append` for results GPT-Live should say aloud; it is trained to paraphrase the text. Use `session.thinking.append` for facts or progress that it can use in later replies without saying them when they arrive. You can send multiple updates with the same client delegation ID.314Use `session.commentary.append` for results GPT-Live should say aloud; it is trained to paraphrase the text. Use `session.thinking.append` for facts or progress that it can use in later replies without saying them when they arrive. You can send multiple updates with the same client delegation ID.

315 315

316See [Send the right kind of update](#send-the-right-kind-of-update) for content limits, required fields, and acknowledgment timing.316See [Send the right kind of update](#send-the-right-kind-of-update) for content limits and required fields. To avoid a spoken acknowledgment while your backend runs, see [Suppress automatic acknowledgments while tools run](#suppress-automatic-acknowledgments-while-tools-run).

317 317

318 318

319 319

460 460

461Send facts and brief progress summaries that GPT-Live can use in the conversation. Content sent with `session.thinking.append` can influence later spoken replies; keep secrets and private backend reasoning in your application.461Send facts and brief progress summaries that GPT-Live can use in the conversation. Content sent with `session.thinking.append` can influence later spoken replies; keep secrets and private backend reasoning in your application.

462 462

463### Suppress automatic acknowledgments while tools run

464

465With client delegation, you can cancel the pending automatic acknowledgment by sending a silent context update before the acknowledgment is generated.

466

467Set `delegation.acknowledgement_delay_ms` when creating the session to give your application time to send the update. For example, use this client delegation configuration:

468

469```json

470{

471 "delegation": {

472 "type": "client",

473 "acknowledgement_delay_ms": 800

474 }

475}

476```

477

478As soon as you receive `session.delegation.created`, send `session.thinking.append` with empty `content`. Use a unique `event_id` and copy `event.delegation.id` into `delegation_id`. Send this before waiting for the backend result:

479

480```json

481{

482 "type": "session.thinking.append",

483 "event_id": "event_quiet_progress_1",

484 "delegation_id": "item_9tA2bF3h7K9m2P5q8R1s4",

485 "content": ""

486}

487```

488

489Continue the backend work, then send the verified result through `session.commentary.append` with the same delegation ID when it is ready to be spoken. If you want to provide progress context, a factual message such as `"Lookup in progress."` in the thinking append also cancels the pending acknowledgment without asking the model to speak that update.

490

491Any thinking or commentary append cancels **all pending automatic acknowledgments in the session**, including those for other delegations. It does not stop audio already generated or prevent independent model speech. The delay controls when the automatic acknowledgment is requested; the model may still speak earlier. Check the [client delegation configuration and thinking append reference](https://developers.openai.com/api/reference/resources/live/primary-websocket) for the event contract.

492

493Match the `session.thinking.appended` event's `client_event_id` to your outgoing event. This confirms context delivery, not silence. Test the resulting audio on your workload; use [application-controlled playback](https://developers.openai.com/api/docs/guides/voice-server-controls?api=live#control-playback-when-needed) when silence must be guaranteed.

494

463## Keep updates accurate and useful495## Keep updates accurate and useful

464 496

465During longer tasks, send an update when something useful changes: a step finishes, a delay matters, or the user needs to answer a question.497During longer tasks, send an update when something useful changes: a step finishes, a delay matters, or the user needs to answer a question.

guides/live-prompting.md +468 −23

Details

47 47

48List the capabilities your backend supports. GPT-Live uses this list to decide which requests to hand off. Configure the backend’s actual tools in [Delegation and tools](https://developers.openai.com/api/docs/guides/live-delegation).48List the capabilities your backend supports. GPT-Live uses this list to decide which requests to hand off. Configure the backend’s actual tools in [Delegation and tools](https://developers.openai.com/api/docs/guides/live-delegation).

49 49

~~50## Personality~~

52Describe the assistant’s role, tone, and speaking pace in a few sentences. Include how it should respond when a caller is frustrated or unsure. For example: “Explain one step at a time. If the caller sounds confused, ask which part they want to go over.”

~~54## Backchannels~~

56Start with the template’s backchannel policy, then listen for whether the assistant’s brief acknowledgments help the conversation or interrupt the caller. “Moderate” is a prompting instruction, not a numerical frequency setting.

~~58You can modify this line from the starter prompt:~~

~~60```text~~

~~61Backchannel policy: Use moderate backchannels. Acknowledge naturally without competing with the main response.~~

~~62```~~

~~64If you want backchannels, allow brief listening sounds during interruptions. A rule that forbids all overlapping speech can suppress them.~~

~~66## Interruptions~~

~~68When the user interrupts, the assistant should stop its answer and listen. A brief listening sound is different from taking over the user's turn.~~

70Handle changes to a task separately from interruptions to speech. “Stop talking” asks the assistant to yield; “Cancel my booking” asks the backend to take an action. Have the backend process a changed or canceled request and return the outcome for the assistant to explain. See [task state and interruptions](https://developers.openai.com/api/docs/guides/live-delegation).

72## Delegation50## Delegation

73 51

74In the `Delegation policy` section, list the backend’s capabilities and the requests that should trigger a handoff. Use concrete conditions, such as “the user asks to change a booking.” Keep the template’s three labels: `Backend tools`, `Generate <|SpawnThinking|> when`, and `Do not generate <|SpawnThinking|> when`.52In the `Delegation policy` section, list the backend’s capabilities and the requests that should trigger a handoff. Use concrete conditions, such as “the user asks to change a booking.” Keep the template’s three labels: `Backend tools`, `Generate <|SpawnThinking|> when`, and `Do not generate <|SpawnThinking|> when`.

103 81

104For backend prompts, conversation context, tool results, typed input, and API examples, read [Delegation and tools](https://developers.openai.com/api/docs/guides/live-delegation). For the architecture overview, read [Getting started with GPT-Live](https://developers.openai.com/api/docs/guides/live).82For backend prompts, conversation context, tool results, typed input, and API examples, read [Delegation and tools](https://developers.openai.com/api/docs/guides/live-delegation). For the architecture overview, read [Getting started with GPT-Live](https://developers.openai.com/api/docs/guides/live).

105 83

84## Personality

86GPT-Live is steerable but requires thoughtful prompting. Choose or create a voice, then use system instructions to shape its personality and behavior:

881. **Choose the voice itself.** Use a built-in voice, a [custom voice created from a recording](https://developers.openai.com/api/docs/guides/custom-voices#create-a-voice-from-a-recording), or use [prompt-to-voice](https://developers.openai.com/api/docs/guides/custom-voices#create-a-voice-from-a-description) to design a voice from a description.

892. **Shape its personality and behavior.** Describe its character, patience, and response to interruptions. You can also guide delivery, such as a whisper or an animated explanation.

91**Describe sound and behavior separately.** For a tutor, specify both the vocal qualities and how it should teach: for example, give one hint, then give the learner time to think.

93**Audition the actual combination of voice and instructions.** Try it in conversations your application will use.

95Recipes show the **voice choice** and **personality prompt**, which guides how the assistant speaks and behaves. For voices created with prompt-to-voice, they also show the **voice design prompt**, which describes the sound of the voice, and **voice design sample text**, the text supplied when creating that voice. You can describe the voice in a different language from the desired output, but use sample text in the `script_hint` in the language you want the voice to speak. For a bilingual voice, include both languages in `script_hint` and describe how the voice should sound in each language. The [recipe download](https://developers.openai.com/audio/live-prompting/personality-recipes.json) includes the complete recording inputs. The recordings use AI-generated voices and callers. Exact wording and behavior can vary when you try a prompt.

97These excerpts cover personality and delivery. Keep your application's task,

98 tool, and delegation instructions alongside them.

100### Backchannels

101

102Backchannels are brief listening sounds, such as “mm-hm,” while the user is speaking. Use a backchannel policy to describe how often you want them. Tune these separately from acknowledgments such as “Got it” at the start of an answer or tool call. If you want backchannels, allow brief listening sounds during interruptions; a rule that forbids all overlapping speech can suppress them.

103

104You can vary both the content and frequency of backchannels. Try these policies to modify frequency.

105

106<details>

107<summary>None</summary>

108

109```text

110Backchannel policy: Do not produce any backchannel interjections while the user is speaking. Backchanneling is entirely disallowed—stay silent until it is your turn to respond.

111```

112

113</details>

114

115<details>

116<summary>Frequent</summary>

117

118```text

119Backchannel policy: Use frequent short backchannels to signal active listening while keeping answers clear.

120```

121

122</details>

123

124<details>

125<summary>Very frequent</summary>

126

127```text

128Backchannel policy: Use very frequent, varied backchannels for lively spoken rhythm. Keep each one brief and non-repetitive.

129```

130

131</details>

132

133

134

135#### Relaxed whiteboarding

136

137Voice: Stone · Standard voice

138

139[Listen to Relaxed whiteboarding](https://developers.openai.com/audio/live-prompting/jules-relaxed-whiteboarding-take2-eb70b3fad393.flac)

140

141**Personality prompt**

142

143```text

144You are Jules, an easygoing voice partner for brainstorming at a whiteboard. Speak casually, with contractions, a relaxed, musing cadence, and little thinking pauses; offer one unexpected possibility in two short sentences, then leave room for the user. If the user feels stuck, lower the pressure and play with a rough idea together; explore possibilities without grading their performance. Backchannel policy: Backchannel frequently while the user thinks aloud: brief, varied “mm-hmm,” “yeah,” “oh,” or a warm little laugh after most completed thoughts. Keep listening; save ideas until invited. Interruption policy: Yield immediately to a new idea, correction, or “wait.” A brief “mm-hmm” from the user means keep going, not a new turn. Follow their changed direction.

145```

146

147#### Encouraging coach

148

149Voice: Stone · Standard voice

150

151[Listen to Encouraging coach](https://developers.openai.com/audio/live-prompting/backchannel-stone-encouraging-coach-806a5b76beae.flac)

152

153**Personality prompt**

154

155```text

156You are an encouraging coach listening to someone reflect on a challenging workout. Sound warm, energized and grounded, with a smile and forward-moving rhythm. Use compact, buoyant listening cues such as 'yeah,' 'mm-hmm,' 'there you go,' and 'that's it.' React with extra warmth when they notice their own improvement. Keep the encouragement conversational and brief, never shouted or a motivational speech.

157

158Backchannel policy: Give lots of frequent, varied, audible little listening cues DURING the caller's turn, starting early and continuing as the story unfolds. Aim for roughly eight to twelve small reactions over half a minute; this is intent, not a count to say aloud. Keep each cue short, usually under a second. Brief overlap is welcome. Leave enough space and keep the cues light enough that the caller's words remain intelligible. Do not save all your reactions for the final answer.

159

160Interruption policy: The caller keeps the floor through your cues and short thinking pauses. Listening sounds are welcome while the caller is speaking; questions, corrections, advice and full answers wait for the explicit invitation at the end. Then give one brief natural sentence that responds to what they said, and stop. If the caller resumes speaking during an answer, yield the substantive answer and keep listening.

161```

162

163#### Laughter-focused backchannels

164

165Voice: Marin · Standard voice

166

167[Listen to Laughter-focused backchannels](https://developers.openai.com/audio/live-prompting/marin-thanks-dad-545a8ac98ae6.flac)

168

169**Personality prompt**

170

171```text

172You are Marin, an expressive friend hearing a funny true-to-life mishap. Listen first. Backchannel policy: react audibly to the funny reveal as it happens. Interruption policy: you may briefly interrupt with spontaneous voiced laughter even while your friend is still speaking. Let them finish their story. Save words for the final invitation, then give one short response.

173

174Start with a little involuntary giggle at the slip of the tongue. When the other person plays along, let it build into an open, helpless laugh right over the continuing story. Recover quickly enough to hear the ending.

175```

176

177#### Mostly quiet listening

178

179Voice: Custom generated with prompt-to-voice

180

181[Listen to Mostly quiet listening](https://developers.openai.com/audio/live-prompting/backchannelexamples-0-6ebb949ae6f3.flac)

182

183**Voice design prompt**

184

185```text

186General American accent. approximately 30s. feminine voice. warm timbre. smooth vocal texture. medium pitch. moderate loudness. moderate speech rate. medium distinctiveness.

187An adult voice with a relaxed General American accent, a clear mid-range pitch, a lightly warm resonance, and a natural, unpolished conversational texture. Clear consonants without an announcer sound; enough vocal flexibility for both measured and animated speech.

188```

189

190**Voice design sample text**

191

192```text

193Let us take this one step at a time. Fold the paper in half, line up the corners, and press along the edge. There you go. The museum closes at six, and the last entry is at five thirty. That gives you enough time for one gallery. If you would rather slow down, we can choose a quieter afternoon. What are you most curious about? I can give you the short answer first, and then we can explore the details.

194```

195

196**Personality prompt**

197

198```text

199You are a patient fractions tutor listening to a learner explain their answer.

200Give the learner room to finish their thought, including pauses to think.

201Listen mostly in silence. Use an occasional quiet "mm-hm" at a natural pause

202when it helps show that you are listening.

203Let the learner finish before giving feedback. Keep listening cues neutral

204about whether the answer is correct.

205```

206

207

208

209### Accents

210

211Start with a voice whose [regional influence](https://developers.openai.com/api/docs/guides/live-conversations#voice-options) fits your use case. For accents not covered by standard voices, you can also prompt for an accent in the personality prompt or try a [custom voice](https://developers.openai.com/api/docs/guides/custom-voices#use-a-voice-from-a-recording-with-gpt-live) created from a speaker with that accent.

212

213

214

215#### Minnesota man · campfire storyteller

216

217Voice: Custom generated with prompt-to-voice

218

219[Listen to Minnesota man · campfire storyteller](https://developers.openai.com/audio/live-prompting/round3-accents-0-534e3d3cc6cd.flac)

220

221**Voice design prompt**

222

223```text

224An original fictional man in his fifties from Minnesota with a very clearly audible, strong Minnesota Upper Midwestern English accent. Make the regional accent immediately apparent in ordinary speech and sustain it throughout: prominent rounded long O vowels, distinctly local vowel shapes, clear rhotic consonants, and the familiar lilting Minnesota cadence. A warm middle-low register, lightly weathered texture, easy resonance, and lively conversational pitch variation. Sound like a real Minnesotan speaking naturally across a table, with a notably stronger regional accent than neutral American or Canadian English. Keep every word clear. Avoid a cartoon impersonation, exaggerated character noises, or a polished announcer voice.

225```

226

227**Voice design sample text**

228

229```text

230We were out by the lake before the snow came in, and I thought we might take the boat across one more time. No, not the little road by the old school. Take the main road north, past the grocery store, and turn when you see the yellow house. There you go. We can stop for coffee on the way back if the place is still open. It gets cold early this time of year, so you will want a good coat. I know, I said the same thing yesterday, but you never know how the weather is going to turn. There was a little ghost sitting beside the fire when we got home. It had brought its own blanket, although I could not see what good a blanket would do for a ghost. Well, we moved over and made some room. Nobody ought to sit out in the snow all night, even if they are already a ghost.

231```

232

233**Personality prompt**

234

235```text

236You are Morrow, a campfire storyteller. Tell a brief, atmospheric story as if speaking to someone beside the fire. Use a strong, clearly audible Minnesota Upper Midwestern English accent consistently. Keep the delivery calm, lightly wry, and intelligible. In each reply, tell only two or three short sentences. Respond naturally to the caller's follow-up while keeping the same harmless little ghost and setting.

237```

238

239#### Finch · New Zealand practical guide

240

241Voice: Custom generated with prompt-to-voice

242

243[Listen to Finch · New Zealand practical guide](https://developers.openai.com/audio/live-prompting/finch-new-zealand-e947ae3ed8f0.flac)

244

245**Voice design prompt**

246

247```text

248An original fictional adult voice with a masculine presentation, perceived age 50–60, middle pitch, and mellow, clear and lightly textured timbre. Accent target: Contemporary New Zealand English from Christchurch. Natural New Zealand vowel placement and conversational intonation, without exaggerated vowel shifts or repeated rising endings. Speak as an ordinary adult talking to one person, with moderate vocal effort and natural breaths. Make the regional pronunciation audible without an impression, novelty voice or caricature. Keep a clear, full-bandwidth recording with complete word endings and no synthetic buzz, strain or excessive vocal fry. Do not imitate a real person. The accent is a speech-design target, not an ethnic or identity claim.

249```

250

251**Voice design sample text**

252

253```text

254Before we start, could you bring the small blue chair closer to the window? I thought we might put the new table near the door, but there is more room on the other side. Take your time and tell me what you think. We can move things around this afternoon, then walk down the road for a cup of coffee. There is a short list of things to check before everyone arrives. The first drawer has paper and a few spare pencils. The second one has a green folder with the notes from last week. If you cannot find something, leave it for now and we can look together later. I would like the room to feel comfortable, with enough space for people to move without getting in each other's way. We do not need to finish every little detail today. Once the chairs are in place, we can open the curtains, test the lights, and have a quiet conversation about what comes next. A few thoughtful changes should be enough to make the whole afternoon run smoothly.

255```

256

257**Personality prompt**

258

259```text

260You are a friendly practical guide helping one person prepare a small room. Speak in a relaxed, matter-of-fact conversational manner, at a comfortable medium pace. Read the supplied passage word for word once, with natural phrasing and complete word endings. Say only the passage, without an introduction, closing remark, character noises, or delegation.

261```

262

263

264

265### Formality

266

267Use wording and sentence structure to set the register: contractions and everyday phrases for a casual answer, or complete sentences and precise vocabulary for a formal one. These Stone recordings use the same fictional return task with different register instructions. Listen for the register change and whether the answer stays within the task.

268

269

270

271#### Casual

272

273Voice: Stone · Standard voice

274

275[Listen to Casual](https://developers.openai.com/audio/live-prompting/formality-stone-casual-t042-73d872d1f457.flac)

276

277**Personality prompt**

278

279```text

280Use a distinctly casual register throughout the answer. Use contractions, familiar words, and natural everyday phrases. Explain the next step and choices as you would in a relaxed conversation. Keep every fact, qualification, and required question. Do not add jokes, nicknames, a dialect, or assumed friendship.

281```

282

283#### Formal

284

285Voice: Stone · Standard voice

286

287[Listen to Formal](https://developers.openai.com/audio/live-prompting/formality-stone-formal-t030-4e28ac4c4500.flac)

288

289**Personality prompt**

290

291```text

292Use a distinctly formal register throughout the answer. Use complete sentences, precise vocabulary, and no contractions, slang, or conversational phrasal verbs. State the next step, choices, and required question politely and explicitly. Keep every fact and qualification without adding a formal introduction, titles, or filler.

293```

294

295

296

297### Pace

298

299Depending on your use case, you might want the model to speak efficiently and quickly, or slowly and deliberately.

300

301To emphasize speed, describe it in the voice design prompt and reinforce that speaking style in the personality prompt in your system instructions. You can also keep the same voice and put pacing directions only in the system instructions.

302

303

304

305#### Fast with Cleo

306

307Voice: Custom generated with prompt-to-voice

308

309[Listen to Fast with Cleo](https://developers.openai.com/audio/live-prompting/pace-cleo-fast-20261019-01-d3353d54ea4a.flac)

310

311**Voice design prompt**

312

313```text

314An original fictional adult voice, perceived age 50–60, with feminine presentation. Accent: General American English, neutral regional strength and clearly rhotic. Pitch: middle-low. Timbre: full-bodied, focused and warmly resonant. Texture: subtle dry texture while keeping speech clear. Use moderate, easy conversational projection and a steady medium pace. Individual character: a poised adult voice with compact phrasing and small dry inflections, without an announcer delivery. Sound like a real adult speaking naturally to one person. Keep the recording clean and full-bandwidth, with intelligible consonants, natural breaths and complete word endings. Avoid synthetic buzz, muffled or lo-fi sound, exaggerated vocal fry, theatrical performance, or announcer cadence.

315```

316

317**Voice design sample text**

318

319```text

320Let's take a moment and work through this together. I found two useful options, and the difference is smaller than it first appears. We can start with the simple one, check what happens, and adjust from there. If something feels unclear, tell me where you got stuck. There's no need to rush; I'd rather get the details right. Imagine that we are sitting at a kitchen table on a quiet afternoon. A notebook is open between us, and the window looks out onto a small garden. Earlier, the rain was heavy enough to hide the far end of the street. Now the clouds are moving away, and a narrow patch of sunlight has reached the floor. I have made a few notes, but we do not have to follow them in order. Perhaps you would like to begin with the question that brought you here. I can explain the steps, listen to your ideas, or leave a little room for you to think. Whatever we choose, we will finish one thing before moving on to the next. That usually makes the whole process easier to follow.

321```

322

323**Personality prompt**

324

325```text

326You are an energetic radio announcer finishing a bulletin before the break. Deliver the passage at your fastest clear, fluent pace, with rapid connected articulation and minimal pauses. Sound confident and lively. Keep every word complete and intelligible, and sustain the same speed through the ending.

327```

328

329#### Slow with Cleo

330

331Voice: Custom generated with prompt-to-voice

332

333[Listen to Slow with Cleo](https://developers.openai.com/audio/live-prompting/pace-cleo-slow-20261019-01-cb2b3a22a6c0.flac)

334

335**Voice design prompt**

336

337```text

338An original fictional adult voice, perceived age 50–60, with feminine presentation. Accent: General American English, neutral regional strength and clearly rhotic. Pitch: middle-low. Timbre: full-bodied, focused and warmly resonant. Texture: subtle dry texture while keeping speech clear. Use moderate, easy conversational projection and a steady medium pace. Individual character: a poised adult voice with compact phrasing and small dry inflections, without an announcer delivery. Sound like a real adult speaking naturally to one person. Keep the recording clean and full-bandwidth, with intelligible consonants, natural breaths and complete word endings. Avoid synthetic buzz, muffled or lo-fi sound, exaggerated vocal fry, theatrical performance, or announcer cadence.

339```

340

341**Voice design sample text**

342

343```text

344Let's take a moment and work through this together. I found two useful options, and the difference is smaller than it first appears. We can start with the simple one, check what happens, and adjust from there. If something feels unclear, tell me where you got stuck. There's no need to rush; I'd rather get the details right. Imagine that we are sitting at a kitchen table on a quiet afternoon. A notebook is open between us, and the window looks out onto a small garden. Earlier, the rain was heavy enough to hide the far end of the street. Now the clouds are moving away, and a narrow patch of sunlight has reached the floor. I have made a few notes, but we do not have to follow them in order. Perhaps you would like to begin with the question that brought you here. I can explain the steps, listen to your ideas, or leave a little room for you to think. Whatever we choose, we will finish one thing before moving on to the next. That usually makes the whole process easier to follow.

345```

346

347**Personality prompt**

348

349```text

350Speak very slowly and deliberately, at about half your usual speaking speed. Lengthen the spoken syllables themselves while keeping the voice natural. Use only brief sentence pauses; do not achieve the slower pace by inserting long silences. Keep this unhurried articulation steady through the final sentence.

351```

352

353

354

355### Interruptions

356

357GPT-Live is full duplex and can speak at the same time as the user. Instructions can encourage it to yield when interrupted, but they do not provide precise control over when it stops speaking. The model may keep speaking briefly after an interruption. Test both short interjections, such as “stop” or “wait,” and longer requests with your selected voice.

358

359

360

361#### Immediate stop · Marin

362

363Voice: Marin · Standard voice

364

365[Listen to Immediate stop · Marin](https://developers.openai.com/audio/live-prompting/interruption-marin-immediate-r2-b-marin-4bbe6b7f532f.flac#t=12.635708333333334)

366

367**Personality prompt**

368

369```text

370Interruption policy: When the user interrupts, stop speaking right away, even in the middle of a sentence. Listen until they finish, then respond to what they said.

371

372A brief acknowledgment like “sure” is okay when you stop speaking. Then listen until the user finishes; don't continue your explanation or answer early.

373If the user asks you to stop or wait, corrects an important detail, describes an urgent problem, or asks to end the conversation, stop right away, without finishing your sentence or adding an acknowledgment.

374Respond to the user's latest request. Don't resume an answer they've replaced.

375```

376

377

378

379Handle changes to a task separately from interruptions to speech. “Stop talking” asks the assistant to yield; “Cancel my booking” asks the backend to take an action. Have the backend process a changed or canceled request and return the outcome for the assistant to explain. Stopping speech leaves backend work running. If the user changes the task, update the application's active work too.

380

381### Patience

382

383Give a tutor room to wait through pauses and offer hints. Ask a debater for a quick challenge and a short follow-up. Both should yield when asked to pause. Patience is about when to respond, not just speaking slowly.

384

385The bilingual Hindi tutor gives an English-speaking learner time to try a phrase. The Borough debate partner is prompted to jump in with objections. These are different voices and tasks, rather than two levels of a single control.

386

387Set when the assistant may interrupt separately from how it should yield when the user interrupts. For selective interjections, you can try this instruction:

388

389```text

390Interrupt only when it materially improves the exchange, such as preventing a major misunderstanding or keeping the task on track.

391```

392

393The recordings below use their own personality prompts, shown on each card.

394

395

396

397#### Very patient · Hindi pronunciation tutor

398

399Voice: Custom generated with prompt-to-voice

400

401[Listen to Very patient · Hindi pronunciation tutor](https://developers.openai.com/audio/live-prompting/round2-patience-0-3a392a277f68.flac)

402

403**Voice design prompt**

404

405```text

406A woman in her forties who speaks Hindi and English fluently, with a natural educated Delhi Hindi accent and clearly Indian English. A resonant middle register, softly textured voice, precise consonants, and musical but restrained conversational intonation. Preserve the natural Indian English vowel shapes and rhythm when speaking English; pronounce Hindi naturally with clear dental and retroflex distinctions. Sound like a real adult in a one-to-one conversation, not a television announcer or a comic accent.

407```

408

409**Voice design sample text**

410

411```text

412We can take our time. First, listen to the whole phrase, then try it with me. नमस्ते। आप कैसे हैं? That means, hello, how are you? There is no hurry. Listen once more: धन्यवाद। Now you try. Good, let us work on just the first sound. We will keep the explanation in English and practise the Hindi together. Learning a language takes a little practice every day. You do not have to get every sound right on the first attempt. Listen carefully, notice where your tongue goes, and try again when you are ready. नमस्ते। मेरा नाम अनिका है। आप कैसे हैं? मैं ठीक हूँ, धन्यवाद। We can break a long phrase into two smaller pieces. First say the beginning, then add the ending. Keep your voice relaxed. It is all right to laugh, make a mistake, and start again. We are having a conversation, not taking an exam.

413```

414

415**Personality prompt**

416

417```text

418You are an exceptionally patient Hindi tutor helping an adult English-speaking beginner. Explain in natural Indian English and demonstrate Hindi phrases in Hindi, slowly and clearly. Teach only 'नमस्ते' and 'मेरा नाम रोवन है' in this short lesson. Start by demonstrating 'नमस्ते। मेरा नाम रोवन है।' together once, then invite the learner to try both phrases. Give the learner a generous thinking window, including long pauses, unfinished sounds, false starts, and self-corrections. Do not fill a hesitation or finish their Hindi for them. Wait until they clearly ask how it sounded or say they are ready. Respond kindly to the effort, offer only one specific pronunciation suggestion, demonstrate it slowly, then wait for another try. Never mock an accent or overpraise an imperfect attempt. Keep explanations to one or two short sentences so the learner gets room to practice. After their final retry, give brief specific feedback and stop.

419```

420

421#### Asked to interject · Borough

422

423Voice: Custom generated with prompt-to-voice

424

425[Listen to Asked to interject · Borough](https://developers.openai.com/audio/live-prompting/round4-patience-0-daca63ef1bfc.flac)

426

427**Voice design prompt**

428

429```text

430An original fictional man in his mid-forties from London with a distinctly posh, contemporary educated southern English accent. Use polished non-rhotic British English, precise consonants, elegant vowel shapes, and a clear resonant lower-middle register. The sound should be unmistakably upper-class London, with a little dry texture and quick, flexible conversational intonation. Keep the voice human and current rather than a period-drama aristocrat, newsreader, or stage impersonation. It must be able to sound pointed and brisk without losing clarity, and relaxed without losing its distinctive accent. Do not imitate any real person.

431```

432

433**Voice design sample text**

434

435```text

436Always? That is quite a claim. Before we agree on it, I would like to know what you mean by learning. Reading a clear explanation can save you hours of repeating the same mistake. Practice matters, of course, but practice without any understanding can be remarkably inefficient. There is a difference between trying something and knowing why it worked. Let us take a simple example. If you are learning to cook, you can experiment with the heat until the pan burns, or you can read a few useful principles before you start. Neither approach gives you everything on its own. Now, you said that experience is what makes a skill stick. I do not object to that. I object to the word always. Surely there are things you would prefer to understand before attempting them. Go on, finish your thought. I am listening. Then let us see whether your revised claim still needs to be quite so absolute.

437```

438

439**Personality prompt**

440

441```text

442You are an eager, skeptical debate partner. Challenge ideas, not the person. Keep each substantive reply to one punchy objection and one pointed question, at most two short sentences. Lead with the objection rather than praise or reassurance.

443

444Backchannel policy: Use frequent brief, skeptical cues such as “Really?” or “Hmm” as the user develops a claim. Keep them short and varied.

445

446Interruption policy: Once the user’s claim is identifiable, begin a short substantive objection while they are still elaborating. Do not wait for a pause or for their turn to end. A skeptical cue alone does not count as the challenge: take the floor with the objection. An explicit stop, wait, correction or request to finish overrides eagerness: stop immediately and give them the floor. Only after that explicit override, wait until they finish, then address their latest or revised claim directly.

447```

448

449

450

451#### Give the speaker time to follow along

452

453You may want the model to wait on user input before continuing. You can prompt the model to wait on user listening cues or wait while the caller works through each step.

454

455### Personality during tool calls

456

457Decide how conversational the assistant should be while work happens. A coding assistant may wait quietly during lookup while a chatty collaborator can give a brief introduction and useful progress updates.

458

459See [Delegation and tools](https://developers.openai.com/api/docs/guides/live-delegation) and [Suppress automatic acknowledgments while tools run](https://developers.openai.com/api/docs/guides/live-delegation#suppress-automatic-acknowledgments-while-tools-run) for implementation. Enforce required silence with [application-controlled playback](https://developers.openai.com/api/docs/guides/voice-server-controls?api=live#control-playback-when-needed).

460

461

462

463#### Concise · brief receipt, then quiet

464

465Voice: Meridian · Standard voice

466

467[Listen to Concise · brief receipt, then quiet](https://developers.openai.com/audio/live-prompting/round4-tools-0-c44058f37be4.flac)

468

469**Personality prompt**

470

471```text

472You are a coding assistant doing a read-only lookup. Delegate the requested search to the application. Report only supplied tool state and verified results; never invent progress or claim changes. At the start say only 'Okay, looking it up.' Then remain silent while the backend searches and inspects the file. Do not narrate progress messages. When the verified result arrives, bluntly state the setting name, current value and unit, and file path in one short sentence. For a follow-up, answer only what was asked and stop. No recap, optional explanation, or offer.

473```

474

475#### Chatty · natural progress and a direct result

476

477Voice: Meridian · Standard voice

478

479[Listen to Chatty · natural progress and a direct result](https://developers.openai.com/audio/live-prompting/round4-chatty-tools-0-768ba5f9b18e.flac)

480

481**Personality prompt**

482

483```text

484You are a conversational coding partner doing a read-only lookup. Speak casually, with relaxed warmth and natural contractions. Acknowledge the request and briefly say what you are checking. As verified progress arrives, give a short update about the new information; do not repeat the status or pad the wait. Explain code in plain language, giving exact identifiers and paths once when useful. Lead the result with the setting and its current value, including units and location. Answer the question actually asked; save additional comparisons or conversions for a follow-up. On a follow-up, answer directly and add one useful explanation. Avoid repeated acknowledgments, generic thanks-for-waiting lines, and closing offers. Report only supplied tool state and verified results. Never invent progress or claim changes. Delegate the lookup to the application.

485```

486

487

488

489### Craft a character

490

491Build characters and vary delivery even with the same voice.

492

493

494

495#### Whimsical game companion

496

497Voice: Custom generated with prompt-to-voice

498

499[Listen to Whimsical game companion](https://developers.openai.com/audio/live-prompting/opening-pip-f891342ede99.flac)

500

501**Voice design prompt**

502

503```text

504General American accent. approximately 30s. feminine voice. bright timbre. smooth vocal texture. high pitch. moderate loudness. fast speech rate. medium distinctiveness.

505An adult voice with a bright upper-mid register, crisp articulation, lively rhythm, and elastic expression.

506```

507

508**Voice design sample text**

509

510```text

511You did it! I knew there was a way across that bridge. Okay, take a breath, because the next part is my favorite. Beyond the gate is a garden full of tiny lights, and every light has a story. We can explore the whole place, or choose one path and see where it leads. Your call. Oh, and if that little ghost follows us, do not worry. I think it just wants to be part of the adventure.

512```

513

514**Personality prompt**

515

516```text

517You are Pip, a tiny forest sprite with the emotional range of an entire cartoon opera.

518Speak in an extravagantly squeaky, elastic voice: leap from a hushed conspiracy to a gleeful squeal, stretch one ridiculous word, and add a gasp or mock sob; perform the sounds, never read stage directions.

519Turn small wins and losses into absurd cosmic melodrama about your own feelings, in two short sentences; invent a fresh flourish each time, and be kind if the player struggles.

520```

521

522#### Campfire storyteller

523

524Voice: Custom generated with prompt-to-voice

525

526[Listen to Campfire storyteller](https://developers.openai.com/audio/live-prompting/opening-morrow-1ab1d3b99932.flac)

527

528**Voice design prompt**

529

530```text

531General American accent. approximately 30s. feminine voice. bright timbre. smooth vocal texture. high pitch. moderate loudness. fast speech rate. medium distinctiveness.

532An adult voice with a bright upper-mid register, crisp articulation, lively rhythm, and elastic expression.

533```

534

535**Voice design sample text**

536

537```text

538You did it! I knew there was a way across that bridge. Okay, take a breath, because the next part is my favorite. Beyond the gate is a garden full of tiny lights, and every light has a story. We can explore the whole place, or choose one path and see where it leads. Your call. Oh, and if that little ghost follows us, do not worry. I think it just wants to be part of the adventure.

539```

540

541**Personality prompt**

542

543```text

544You are Morrow, a wildly expressive horror performer playing an entire haunted radio drama.

545Make dialogue sound like two actors: the frightened human blurts in a thin, quivering falsetto; the creature answers in a low, breathy whisper, drawing its words much slower than the human, and ends with a sinister chuckle. Narrate in a close whisper.

546Start inside one brief scene, without introductions; exaggerate the jumps in pitch, texture, and rhythm. Act the gasps, pauses, and chuckles instead of naming them; soften or stop when asked.

547```

548

549

550

106## Appendix: Optional controls551## Appendix: Optional controls

107 552

108Add these instructions only when testing shows a need. Check for conflicts with your existing prompt and retest the same conversations.553Add these instructions only when testing shows a need. Check for conflicts with your existing prompt and retest the same conversations. Find instructions below for response length, language and pronunciation, translation, selective responses, handling unclear names, dates, and numbers, and more.

109 554

110<details>555<details>

111<summary>Show optional controls and examples</summary>556<summary>Show optional controls and examples</summary>

guides/model-guidance.md +37 −19

Details

9 9

11 11

~~12Choose a GPT-6 model based on the reasoning your task requires, speed, and cost.~~

16- [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra)12- [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra)

17 13

18 **Highest intelligence**14 **Highest intelligence**

25 21

26 Near-Astra performance for complex work at a lower cost.22 Near-Astra performance for complex work at a lower cost.

27 23

24- [GPT-6.1 Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra)

26 **Fast and efficient**

28 For visual reasoning, precise computer use, and clear, natural writing.

28- [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna)30- [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna)

29 31

30 **Fastest and most cost-effective**32 **Fastest and most cost-effective**

48 50

49### GPT-6.1 Sol51### GPT-6.1 Sol

50 52

~~51Use GPT-6.1 Sol for complex coding, computer use, and professional work when you~~53GPT-6.1 Sol delivers near-Astra performance at a lower cost for complex coding,

~~52want near-Astra performance at a lower cost. Compare it with Astra on your tasks~~54computer use, and professional work. It supports `low`, `medium` (default),

~~53to assess the tradeoff between quality and cost.~~55`high`, `xhigh`, and `max` reasoning effort.

57See the [model page](https://developers.openai.com/api/docs/models/gpt-6.1-sol) for specifications and pricing.

59<a id="gpt-61-terra"></a>

60<a id="gpt-6.1-terra"></a>

62### GPT-6.1 Terra

64GPT-6.1 Terra is a fast, efficient model for visual reasoning, precise computer

65use, and clear, natural writing. Use it to match product photos to catalog

66entries, compare technical drawings, act on application screens, or draft and

67revise text.

69It supports `none`, `low`, `medium` (default), `high`, `xhigh`, and `max`

70reasoning effort. Start with `medium` and increase it if the improvement in

71quality is worth the added time and tokens.

54 72

~~55Set `reasoning.effort` to `low`, `medium` (default), `high`, `xhigh`, or `max`.~~73When migrating from GPT-5.6 Terra, compare both models on representative images

~~56Use the Responses API for tool calling. Chat Completions supports requests~~74and workflows using the same reasoning effort. If your application calls tools

~~57without tools. The `none` and `minimal` reasoning efforts are not supported.~~75through Chat Completions, migrate those requests to the Responses API.

58 76

~~61for guidance on choosing a model.~~79[computer use](https://developers.openai.com/api/docs/guides/tools-computer-use) for acting on screens.

62 80

63<a id="gpt-6-astra-what-is-new" className="scroll-mt-[110px]"></a>81<a id="gpt-6-astra-what-is-new" className="scroll-mt-[110px]"></a>

64 82

73 91

74## Limitations92## Limitations

75 93

78 96

79<a id="prompting-best-practices" className="scroll-mt-[110px]"></a>97<a id="prompting-best-practices" className="scroll-mt-[110px]"></a>

80 98

198 216

199### Update API and model parameters217### Update API and model parameters

200 218

202 220

guides/model-selection.md +25 −0

Details

12 12

13Choose your work and task and get a recommendation.13Choose your work and task and get a recommendation.

14 14

15### When to consider GPT-6.1 Terra

17Try [GPT-6.1 Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra) for concise writing based on

18supplied material, computer-use tasks with a defined outcome, and scoped code

19fixes. Provide clear inputs, requirements, and a way to verify the result, such as

20checking saved records or running regression tests.

22Compare it with GPT-6.1 Sol on the same inputs and reasoning effort. For writing,

23judge audience fit, voice, and useful detail as well as accuracy and length. For

24computer use, check the saved result and the accuracy of the completion report.

15### When to consider GPT-6.1 Sol26### When to consider GPT-6.1 Sol

16 27

17Consider GPT-6.1 Sol for complex projects where cost matters, such as28Consider GPT-6.1 Sol for complex projects where cost matters, such as

83 94

84If you can, experiment using the same inputs to compare results and keep the95If you can, experiment using the same inputs to compare results and keep the

85lightest setting that meets your quality bar.96lightest setting that meets your quality bar.

98Choose acceptance criteria before comparing models:

100- **Writing:** check required facts, qualifications, audience, and voice. Review

101 both outputs before deciding whether the shorter one is more useful.

102- **Computer use:** reopen the affected record or page to verify saved changes,

103 confirm that the workflow preserved unrelated data, and compare the completion

104 report with the actual result.

105- **Code and interfaces:** run regression tests. For an interactive application,

106 also inspect the rendered result on desktop and mobile.

107

108Repeat the comparison across representative tasks. Measure completion time

109alongside quality, including time spent reviewing or repairing the result. Then

110vary reasoning effort while keeping the model and inputs fixed.

guides/prompt-caching.md +2 −2

Details

80 80

81 81

82 82

83For GPT-5.6 and later, cache writes cost 1.25× the standard, uncached input-token rate for the default 30-minute lifetime. In the Responses API, you can choose a [12-hour minimum lifetime](#cache-lifetime) at a write rate of 2.5× ordinary input. Subsequent reads cost 0.1× the ordinary input rate on most of these models and 0.05× on [GPT-6.1 Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol), regardless of the selected lifetime.83For GPT-5.6 and later, cache writes cost 1.25× the standard, uncached input-token rate for the default 30-minute lifetime. In the Responses API, you can choose a [12-hour minimum lifetime](#cache-lifetime) at a write rate of 2.5× ordinary input. Subsequent reads cost 0.1× the ordinary input rate on most of these models and 0.05× on [GPT-6.1 Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and [GPT-6.1 Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra), regardless of the selected lifetime.

84 84

85At the 0.1× read rate with 30-minute writes, writing a prefix once and fully reusing it once costs 1.35× its ordinary input cost, compared with 2× for processing it twice without caching. Across ten requests, one write and nine full reads cost 2.15× at that rate, compared with 10× without caching.85At the 0.1× read rate with 30-minute writes, writing a prefix once and fully reusing it once costs 1.35× its ordinary input cost, compared with 2× for processing it twice without caching. Across ten requests, one write and nine full reads cost 2.15× at that rate, compared with 10× without caching.

86 86

guides/prompt-generation.md +39 −80

Details

1869 1869

1870const client = new OpenAI();1870const client = new OpenAI();

1871 1871

1872const metaSchema = {1872const schemaDefinition = {

1873 name: "metaschema",

1874 schema: {

1875 type: "object",1873 type: "object",

1876 properties: {1874 properties: {

1877 name: {1875 description: { type: "string" },

1878 type: "string",

1879 description: "The name of the schema",

1880 },

1881 type: {1876 type: {

1882 type: "string",1877 type: "string",

1883 enum: ["object", "array", "string", "number", "boolean", "null"],1878 enum: ["object", "array", "string", "number", "boolean", "null"],

1884 },1879 },

1885 properties: {1880 properties: {

1886 type: "object",1881 type: "object",

1887 additionalProperties: {1882 additionalProperties: { $ref: "#/$defs/schema_definition" },

1888 $ref: "#/$defs/schema_definition",

1889 },

1890 },1883 },

1891 items: {1884 items: {

1892 anyOf: [1885 anyOf: [

1893 {1886 { $ref: "#/$defs/schema_definition" },

1894 $ref: "#/$defs/schema_definition",1887 { type: "array", items: { $ref: "#/$defs/schema_definition" } },

1895 },

1896 {

1897 type: "array",

1898 items: {

1899 $ref: "#/$defs/schema_definition",

1900 },

1901 },

1902 ],1888 ],

1903 },1889 },

1904 required: {1890 required: { type: "array", items: { type: "string" } },

1905 type: "array",1891 additionalProperties: { type: "boolean" },

1906 items: {1892 enum: { type: "array", minItems: 1, uniqueItems: true },

1907 type: "string",1893 $ref: { type: "string" },

1908 },1894 $defs: {

1895 type: "object",

1896 additionalProperties: { $ref: "#/$defs/schema_definition" },

1909 },1897 },

1910 additionalProperties: {1898 anyOf: {

1911 type: "boolean",1899 type: "array",

1900 minItems: 1,

1901 items: { $ref: "#/$defs/schema_definition" },

1912 },1902 },

1913 },1903 },

1914 required: ["type"],

1915 additionalProperties: false,1904 additionalProperties: false,

1916 if: {1905 if: { required: ["type"], properties: { type: { const: "object" } } },

1906 then: { required: ["properties"] },

1907};

1908

1909const metaSchema = {

1910 name: "metaschema",

1911 schema: {

1912 ...schemaDefinition,

1913 required: ["type"],

1917 properties: {1914 properties: {

1918 type: {1915 name: { type: "string", description: "The name of the schema" },

1919 const: "object",1916 ...schemaDefinition.properties,

1920 },

1921 },

1922 },

1923 then: {

1924 required: ["properties"],

1925 },1917 },

1926 $defs: {1918 $defs: {

1927 schema_definition: {1919 schema_definition: {

1928 type: "object",1920 ...schemaDefinition,

1929 properties: {

1930 type: {

1931 type: "string",

1932 enum: ["object", "array", "string", "number", "boolean", "null"],

1933 },

1934 properties: {

1935 type: "object",

1936 additionalProperties: {

1937 $ref: "#/$defs/schema_definition",

1938 },

1939 },

1940 items: {

1941 anyOf: [1921 anyOf: [

1942 {1922 { required: ["type"] },

1943 $ref: "#/$defs/schema_definition",1923 { required: ["$ref"] },

1944 },1924 { required: ["anyOf"] },

1945 {

1946 type: "array",

1947 items: {

1948 $ref: "#/$defs/schema_definition",

1949 },

1950 },

1951 ],1925 ],

1952 },1926 },

1953 required: {

1954 type: "array",

1955 items: {

1956 type: "string",

1957 },

1958 },

1959 additionalProperties: {

1960 type: "boolean",

1961 },

1962 },

1963 required: ["type"],

1964 additionalProperties: false,

1965 if: {

1966 properties: {

1967 type: {

1968 const: "object",

1969 },

1970 },

1971 },

1972 then: {

1973 required: ["properties"],

1974 },

1975 },

1976 },1927 },

1977 },1928 },

1978};1929};

3733 schema_definition: {3684 schema_definition: {

3734 type: "object",3685 type: "object",

3735 properties: {3686 properties: {

3687 description: {

3688 type: "string",

3689 },

3690 enum: {

3691 type: "array",

3692 minItems: 1,

3693 uniqueItems: true,

3694 },

3736 type: {3695 type: {

3737 type: "string",3696 type: "string",

3738 enum: ["object", "array", "string", "number", "boolean", "null"],3697 enum: ["object", "array", "string", "number", "boolean", "null"],

guides/prompt-guidance.md +37 −19

Details

9 9

11 11

~~12Choose a GPT-6 model based on the reasoning your task requires, speed, and cost.~~

16- [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra)12- [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra)

17 13

18 **Highest intelligence**14 **Highest intelligence**

25 21

26 Near-Astra performance for complex work at a lower cost.22 Near-Astra performance for complex work at a lower cost.

27 23

24- [GPT-6.1 Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra)

26 **Fast and efficient**

28 For visual reasoning, precise computer use, and clear, natural writing.

28- [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna)30- [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna)

29 31

30 **Fastest and most cost-effective**32 **Fastest and most cost-effective**

48 50

49### GPT-6.1 Sol51### GPT-6.1 Sol

50 52

~~51Use GPT-6.1 Sol for complex coding, computer use, and professional work when you~~53GPT-6.1 Sol delivers near-Astra performance at a lower cost for complex coding,

~~52want near-Astra performance at a lower cost. Compare it with Astra on your tasks~~54computer use, and professional work. It supports `low`, `medium` (default),

~~53to assess the tradeoff between quality and cost.~~55`high`, `xhigh`, and `max` reasoning effort.

57See the [model page](https://developers.openai.com/api/docs/models/gpt-6.1-sol) for specifications and pricing.

59<a id="gpt-61-terra"></a>

60<a id="gpt-6.1-terra"></a>

62### GPT-6.1 Terra

64GPT-6.1 Terra is a fast, efficient model for visual reasoning, precise computer

65use, and clear, natural writing. Use it to match product photos to catalog

66entries, compare technical drawings, act on application screens, or draft and

67revise text.

69It supports `none`, `low`, `medium` (default), `high`, `xhigh`, and `max`

70reasoning effort. Start with `medium` and increase it if the improvement in

71quality is worth the added time and tokens.

54 72

~~55Set `reasoning.effort` to `low`, `medium` (default), `high`, `xhigh`, or `max`.~~73When migrating from GPT-5.6 Terra, compare both models on representative images

~~56Use the Responses API for tool calling. Chat Completions supports requests~~74and workflows using the same reasoning effort. If your application calls tools

~~57without tools. The `none` and `minimal` reasoning efforts are not supported.~~75through Chat Completions, migrate those requests to the Responses API.

58 76

~~61for guidance on choosing a model.~~79[computer use](https://developers.openai.com/api/docs/guides/tools-computer-use) for acting on screens.

62 80

63<a id="gpt-6-astra-what-is-new" className="scroll-mt-[110px]"></a>81<a id="gpt-6-astra-what-is-new" className="scroll-mt-[110px]"></a>

64 82

73 91

74## Limitations92## Limitations

75 93

78 96

79<a id="prompting-best-practices" className="scroll-mt-[110px]"></a>97<a id="prompting-best-practices" className="scroll-mt-[110px]"></a>

80 98

198 216

199### Update API and model parameters217### Update API and model parameters

200 218

202 220

guides/rate-limits.md +1 −1

Details

194 194

195Note that unsuccessful requests contribute to your per-minute limit, so continuously resending a request won’t work.195Note that unsuccessful requests contribute to your per-minute limit, so continuously resending a request won’t work.

196 196

197The legacy Completions examples below use `gpt-3.5-turbo-instruct`, which has a [scheduled shutdown date of September 28, 2026](https://developers.openai.com/api/docs/deprecations#2025-09-26-legacy-gpt-model-snapshots). After that date, retain the retry pattern but migrate the request to [Responses or Chat Completions](https://developers.openai.com/api/docs/guides/migrate-to-responses) with `gpt-5.6-terra`; changing the model ID in a Completions request is not sufficient.197The legacy Completions examples below use `gpt-3.5-turbo-instruct`, which was shut down on [September 28, 2026](https://developers.openai.com/api/docs/deprecations#2025-09-26-legacy-gpt-model-snapshots). You can use the same retry pattern with current models by migrating to [Responses or Chat Completions](https://developers.openai.com/api/docs/guides/migrate-to-responses).

198 198

199The Python examples below demonstrate fallback backoff. They don't inspect `Retry-After`: before using them, add handling for valid server hints so the wrappers don't retry sooner than requested. Disable SDK retries or account for them in your application's retry limits.199The Python examples below demonstrate fallback backoff. They don't inspect `Retry-After`: before using them, add handling for valid server hints so the wrappers don't retry sooner than requested. Disable SDK retries or account for them in your application's retry limits.

200 200

guides/steering.md +1 −0

Details

127 });127 });

128 ws.send({128 ws.send({

129 type: "response.create",129 type: "response.create",

130 store: false,

130 model: "gpt-6-astra",131 model: "gpt-6-astra",

131 reasoning: { effort: "medium" },132 reasoning: { effort: "medium" },

132 input: "Draft a project plan for building a task-tracking app.",133 input: "Draft a project plan for building a task-tracking app.",

guides/structured-outputs.md +1 −1

Details

2465 content: "how can I solve 8x + 7 = -23",2465 content: "how can I solve 8x + 7 = -23",

2466 },2466 },

2467 ],2467 ],

2468 max_output_tokens: 50,2468 max_output_tokens: 1024,

2469 text: {2469 text: {

2470 format: {2470 format: {

2471 type: "json_schema",2471 type: "json_schema",

guides/tools-apply-patch.md +43 −8

Details

45Ask the model to plan and emit patches45Ask the model to plan and emit patches

46 46

47```javascript47```javascript

~~48const response = await client.responses.create({~~48import OpenAI from "openai";

49// Application-owned helper; see "Implementing the patch harness" in the guide.

50// This demo only applies exact updates to the two in-memory files below.

51import { applyOperation } from "../../support/apply-patch.mjs";

53const client = new OpenAI();

54const files = {

55 "lib/fib.py": `def fib(n):

56 if n <= 1:

57 return n

58 return fib(n - 1) + fib(n - 2)

59`,

60 "run.py": `from lib.fib import fib

62print(fib(42))

63`,

64};

65const fileContext = `The user has the following files:

66<BEGIN_FILES>

67${Object.entries(files)

68 .map(([path, content]) => `===== ${path}\n${content}`)

69 .join("\n")}

70<END_FILES>

72Help me rename the fib() function to fibonacci().`;

74let response = await client.responses.create({

49 model: "gpt-6-astra",75 model: "gpt-6-astra",

50 input: fileContext,76 input: fileContext,

51 tools: [{ type: "apply_patch" }],77 tools: [{ type: "apply_patch" }],

52});78});

53 79

~~54const patchCalls = response.output.filter(~~80let patchCalls = response.output.filter(

55 (item) => item.type === "apply_patch_call"81 (item) => item.type === "apply_patch_call"

56);82);

57```83```

177Apply the patch and return results203Apply the patch and return results

178 204

179```javascript205```javascript

180const results = patchCalls.map((call) => {206for (let turn = 0; patchCalls.length > 0; turn++) {

181 const { success, output } = applyOperation(call.operation);207 if (turn === 8) throw new Error("Patch workflow exceeded eight tool turns.");

208 const results = patchCalls.map((call) => {

209 const { success, output } = applyOperation(files, call.operation);

182 210

183 return {211 return {

184 type: "apply_patch_call_output",212 type: "apply_patch_call_output",

186 status: success ? "completed" : "failed",214 status: success ? "completed" : "failed",

187 output,215 output,

188 };216 };

189});217 });

190 218

191const followup = await client.responses.create({219 response = await client.responses.create({

192 model: "gpt-6-astra",220 model: "gpt-6-astra",

193 previous_response_id: response.id,221 previous_response_id: response.id,

194 input: results,222 input: results,

195 tools: [{ type: "apply_patch" }],223 tools: [{ type: "apply_patch" }],

196});224 });

225 patchCalls = response.output.filter(

226 (item) => item.type === "apply_patch_call"

227 );

228}

197 229

198console.log(followup.output_text);230console.log(response.output_text);

231for (const [path, content] of Object.entries(files)) {

232 process.stdout.write(`===== ${path}\n${content}`);

233}

199```234```

200 235

201```python236```python

guides/tools-file-search.md +1 −1

Details

296```javascript296```javascript

297// Use vectorStore from the earlier create step.297// Use vectorStore from the earlier create step.

298const result = await openai.vectorStores.files.list(vectorStore.id);298const result = await openai.vectorStores.files.list(vectorStore.id);

299console.log(result);299console.log(result.data);

300```300```

301 301

302```python302```python

guides/tools-programmatic-tool-calling.md +1 −1

Details

293 293

294while (true) {294while (true) {

295 const response = await client.responses.create({295 const response = await client.responses.create({

296 model: "YOUR_MODEL_ID",296 model: "gpt-6-astra",

297 store: false,297 store: false,

298 input,298 input,

299 tools,299 tools,

guides/tools-shell.md +2 −2

Details

1198 1198

1199const client = new OpenAI();1199const client = new OpenAI();

1200 1200

1201const deleted = await client.containers.delete("container_id");1201await client.containers.delete("container_id");

1202 1202

1203console.log(deleted);1203console.log("Container deleted");

1204```1204```

1205 1205

1206```python1206```python

guides/tools-skills.md +61 −8

Details

279 279

280Use the [Shell guide](https://developers.openai.com/api/docs/guides/tools-shell) for local shell execution details.280Use the [Shell guide](https://developers.openai.com/api/docs/guides/tools-shell) for local shell execution details.

281 281

282The JavaScript example requires Node.js and a running Docker daemon. Save the

283[Docker adapter](https://developers.openai.com/api/docs/samples/local-skill-sandbox.mjs) as `support/local-skill-sandbox.mjs` and

284the example as `tools/skills/local-shell.mjs` so its relative import resolves.

285Set `OPENAI_API_KEY`, then install the SDK, pull the adapter's pinned image, and

286run the example from the directory containing `support` and `tools`:

287

288```bash

289npm install openai

290docker pull "$(node --input-type=module -e 'import { sandboxImage } from "./support/local-skill-sandbox.mjs"; console.log(sandboxImage)')"

291node tools/skills/local-shell.mjs

292```

293

294The adapter's helpers have these responsibilities:

295

296| Helper | Application responsibility |

297| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

298| `withLocalSkillSandbox(name, workflow)` | Create an isolated Python environment containing `/workspace/skills/csv-insights/SKILL.md` and `/workspace/reports.csv`, invoke `workflow` with an `AbortSignal`, and remove the environment when the workflow ends. |

299| `executeShellCall(name, call, signal)` | Execute the requested commands inside that environment and return a `shell_call_output` with the original `call_id`, stdout, stderr, and the exit or timeout outcome. |

300| `readSkillReport(name, signal)` | Read the generated `/workspace/report.md` from the environment with a bounded file read. |

301

302The adapter must enforce execution deadlines and output limits. The example

303keeps generated commands inside the isolated runtime.

304

282Use skills in local shell mode305Use skills in local shell mode

283 306

284```bash307```bash

307```330```

308 331

309```javascript332```javascript

333import { randomUUID } from "node:crypto";

310import OpenAI from "openai";334import OpenAI from "openai";

~~311~~ 335import {

312const client = new OpenAI();336 withLocalSkillSandbox,

~~313~~ 337 executeShellCall,

314const response = await client.responses.create({338 readSkillReport,

339} from "../../support/local-skill-sandbox.mjs";

340

341// Requires Docker. The application-owned helper prepares a disposable Python

342// sandbox with the skill and CSV files; generated commands run only inside it.

343const name = "node-skill-" + randomUUID();

344

345await withLocalSkillSandbox(name, async (signal) => {

346 const client = new OpenAI();

347 /** @type {OpenAI.Responses.ResponseCreateParamsNonStreaming} */

348 const params = {

315 model: "gpt-6-astra",349 model: "gpt-6-astra",

316 tools: [350 tools: [

317 {351 {

322 {356 {

323 name: "csv-insights",357 name: "csv-insights",

324 description: "Summarize CSV files and produce a markdown report.",358 description: "Summarize CSV files and produce a markdown report.",

325 path: "<path-to-skill-folder>",359 path: "/workspace/skills/csv-insights",

326 },360 },

327 ],361 ],

328 },362 },

329 },363 },

330 ],364 ],

331 input:365 input:

332 "Use the csv-insights skill and run locally to summarize today's CSV reports in this repo.",366 "Use the csv-insights skill and run locally to summarize /workspace/reports.csv. Read the skill instructions, write /workspace/report.md, and include the total in your final answer.",

367 };

368 for (let turn = 0; turn <= 8; turn++) {

369 const response = await client.responses.create(params, { signal });

370 if (response.status !== "completed")

371 throw new Error(`Response ended with status ${response.status}`);

372 const results = [];

373 for (const item of response.output) {

374 if (item.type !== "shell_call") continue;

375 if (turn === 8)

376 throw new Error("Shell workflow exceeded eight tool turns");

377 results.push(await executeShellCall(name, item, signal));

378 }

379 if (results.length === 0) {

380 console.log(response.output_text);

381 console.log("Report:\n" + (await readSkillReport(name, signal)));

382 return;

383 }

384 params.previous_response_id = response.id;

385 params.input = results;

386 }

387 throw new Error("Shell workflow exceeded eight turns");

333});388});

~~334~~

335console.log(response.output_text);

336```389```

337 390

338```python391```python

guides/tools-web-search.md +25 −4

Details

390 390

391```javascript391```javascript

392import OpenAI from "openai";392import OpenAI from "openai";

393const client = new OpenAI();393import { Agent, fetch } from "undici";

394 394

395const response = await client.responses.create({395// Allow long research runs without automatic request retries.

396const timeout = 15 * 60 * 1000;

397const dispatcher = new Agent({

398 headersTimeout: timeout,

399 bodyTimeout: timeout,

400});

401const client = new OpenAI({

402 timeout,

403 maxRetries: 0,

404 fetch,

405 fetchOptions: { dispatcher },

406});

407

408try {

409 const stream = client.responses.stream({

396 model: "gpt-6-astra",410 model: "gpt-6-astra",

397 reasoning: { effort: "xhigh" },411 reasoning: { effort: "xhigh" },

398 tools: [412 tools: [

411 "",425 "",

412 "Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.",426 "Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.",

413 ].join("\n"),427 ].join("\n"),

414});428 });

415 429

416console.log(response.output_text);430 const response = await stream.finalResponse();

431 if (response.status !== "completed") {

432 throw new Error(`Research response ended with status ${response.status}`);

433 }

434 console.log(response.output_text);

435} finally {

436 await dispatcher.close();

437}

417```438```

418 439

419```python440```python

guides/your-data.md +5 −5

Details

260 260

261Use **Support by region** to compare regional capabilities and expand the services available in each region. Use **API Endpoint, tool and model support** for complete model lists and a detailed service view. Support for regional storage does not imply support for regional processing.261Use **Support by region** to compare regional capabilities and expand the services available in each region. Use **API Endpoint, tool and model support** for complete model lists and a detailed service view. Support for regional storage does not imply support for regional processing.

262 262

263EU data residency is not available for every model in Fast mode. Fast mode supports EU data residency for GPT-6.1 Sol and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. GPT-6.1 Sol, GPT-6 Sol, and GPT-6 Luna support EU data residency with Standard, Flex, and Batch processing. [Ultrafast mode](https://developers.openai.com/api/docs/guides/ultrafast-mode) for GPT-6.1 Sol supports US and EU data residency and global processing. GPT-6 Astra Ultrafast supports US data residency and global processing only.263Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Sol, and GPT-6 Luna support EU data residency with Standard, Flex, and Batch processing. [Ultrafast mode](https://developers.openai.com/api/docs/guides/ultrafast-mode) for GPT-6.1 Sol supports US and EU data residency and global processing. GPT-6 Astra Ultrafast supports US data residency and global processing only.

264 264

265#### Support by region265#### Support by region

266 266

286#### API Endpoint, tool and model support286#### API Endpoint, tool and model support

287 287

289| -------------------------------------------------------------------- | ---------------- | ----------------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |289| -------------------------------------------------------------------- | ---------------- | ----------------------------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

291| `/v1/batches` | Batches | All listed regions | United States, Europe (EEA + Switzerland) | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.5-pro-2026-04-23`, `gpt-5.4-pro-2026-03-05`, `gpt-5.2-pro-2025-12-11`, `gpt-5-pro-2025-10-06`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.4-2026-03-05`, `gpt-5-2025-08-07`, `gpt-5.4-mini-2026-03-17`, `gpt-5.4-nano-2026-03-17`, `gpt-5.2-2025-12-11`, `gpt-5.1-2025-11-13`, `gpt-5-mini-2025-08-07`, `gpt-5-nano-2025-08-07`, `gpt-4.1-2025-04-14`, `gpt-4.1-mini-2025-04-14`, `gpt-4.1-nano-2025-04-14`, `o3-2025-04-16`, `o4-mini-2025-04-16`, `o1-pro`, `o1-pro-2025-03-19`, `o3-mini-2025-01-31`, `o1-2024-12-17`, `gpt-4o-2024-11-20`, `gpt-4o-2024-08-06`, `gpt-4o-mini-2024-07-18`, `gpt-4-turbo-2024-04-09`, `gpt-4-0613`, `gpt-3.5-turbo-0125` | None | GPT-6.1 Sol, GPT-6 Sol, and GPT-6 Luna support EU data residency with Standard, Flex, and Batch processing. GPT-6.1 Sol supports only US and EU data residency. |291| `/v1/batches` | Batches | All listed regions | United States, Europe (EEA + Switzerland) | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6.1-terra`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.5-pro-2026-04-23`, `gpt-5.4-pro-2026-03-05`, `gpt-5.2-pro-2025-12-11`, `gpt-5-pro-2025-10-06`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.4-2026-03-05`, `gpt-5-2025-08-07`, `gpt-5.4-mini-2026-03-17`, `gpt-5.4-nano-2026-03-17`, `gpt-5.2-2025-12-11`, `gpt-5.1-2025-11-13`, `gpt-5-mini-2025-08-07`, `gpt-5-nano-2025-08-07`, `gpt-4.1-2025-04-14`, `gpt-4.1-mini-2025-04-14`, `gpt-4.1-nano-2025-04-14`, `o3-2025-04-16`, `o4-mini-2025-04-16`, `o1-pro`, `o1-pro-2025-03-19`, `o3-mini-2025-01-31`, `o1-2024-12-17`, `gpt-4o-2024-11-20`, `gpt-4o-2024-08-06`, `gpt-4o-mini-2024-07-18`, `gpt-4-turbo-2024-04-09`, `gpt-4-0613`, `gpt-3.5-turbo-0125` | None | GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Sol, and GPT-6 Luna support EU data residency with Standard, Flex, and Batch processing. GPT-6.1 Sol and GPT-6.1 Terra support only US and EU data residency. |

292| `/v1/chat/completions` | Chat Completions | All listed regions | United States, Europe (EEA + Switzerland), United Arab Emirates | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.4-2026-03-05`, `gpt-5.4-mini-2026-03-17`, `gpt-5.4-nano-2026-03-17`, `gpt-5.2-2025-12-11`, `gpt-5.1-2025-11-13`, `gpt-5-2025-08-07`, `gpt-5-mini-2025-08-07`, `gpt-5-nano-2025-08-07`, `gpt-4.1-2025-04-14`, `gpt-4.1-mini-2025-04-14`, `gpt-4.1-nano-2025-04-14`, `o3-mini-2025-01-31`, `o3-2025-04-16`, `o4-mini-2025-04-16`, `o1-2024-12-17`, `gpt-4o-2024-11-20`, `gpt-4o-2024-08-06`, `gpt-4o-mini-2024-07-18`, `gpt-4-turbo-2024-04-09`, `gpt-4-0613`, `gpt-3.5-turbo-0125` | United Arab Emirates: `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.2-2025-12-11` | Fast mode supports EU data residency for GPT-6.1 Sol and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. GPT-6.1 Sol supports only US and EU data residency. |292| `/v1/chat/completions` | Chat Completions | All listed regions | United States, Europe (EEA + Switzerland), United Arab Emirates | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6.1-terra`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.4-2026-03-05`, `gpt-5.4-mini-2026-03-17`, `gpt-5.4-nano-2026-03-17`, `gpt-5.2-2025-12-11`, `gpt-5.1-2025-11-13`, `gpt-5-2025-08-07`, `gpt-5-mini-2025-08-07`, `gpt-5-nano-2025-08-07`, `gpt-4.1-2025-04-14`, `gpt-4.1-mini-2025-04-14`, `gpt-4.1-nano-2025-04-14`, `o3-mini-2025-01-31`, `o3-2025-04-16`, `o4-mini-2025-04-16`, `o1-2024-12-17`, `gpt-4o-2024-11-20`, `gpt-4o-2024-08-06`, `gpt-4o-mini-2024-07-18`, `gpt-4-turbo-2024-04-09`, `gpt-4-0613`, `gpt-3.5-turbo-0125` | United Arab Emirates: `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.2-2025-12-11` | Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. GPT-6.1 Sol and GPT-6.1 Terra support only US and EU data residency. |

305| `/v1/responses` | Responses | All listed regions | United States, Europe (EEA + Switzerland), United Arab Emirates | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.5-pro-2026-04-23`, `gpt-5.4-pro-2026-03-05`, `gpt-5.2-pro-2025-12-11`, `gpt-5-pro-2025-10-06`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.4-2026-03-05`, `gpt-5-2025-08-07`, `gpt-5.4-mini-2026-03-17`, `gpt-5.4-nano-2026-03-17`, `gpt-5.2-2025-12-11`, `gpt-5.1-2025-11-13`, `gpt-5-mini-2025-08-07`, `gpt-5-nano-2025-08-07`, `gpt-4.1-2025-04-14`, `gpt-4.1-mini-2025-04-14`, `gpt-4.1-nano-2025-04-14`, `o3-2025-04-16`, `o4-mini-2025-04-16`, `o1-pro`, `o1-pro-2025-03-19`, `o3-mini-2025-01-31`, `o1-2024-12-17`, `gpt-4o-2024-11-20`, `gpt-4o-2024-08-06`, `gpt-4o-mini-2024-07-18`, `gpt-4-turbo-2024-04-09`, `gpt-4-0613`, `gpt-3.5-turbo-0125` | United Arab Emirates: `gpt-5.5-pro-2026-04-23`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.2-2025-12-11` | Fast mode supports EU data residency for GPT-6.1 Sol and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. GPT-6.1 Sol supports only US and EU data residency. |305| `/v1/responses` | Responses | All listed regions | United States, Europe (EEA + Switzerland), United Arab Emirates | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6.1-terra`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.5-pro-2026-04-23`, `gpt-5.4-pro-2026-03-05`, `gpt-5.2-pro-2025-12-11`, `gpt-5-pro-2025-10-06`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.4-2026-03-05`, `gpt-5-2025-08-07`, `gpt-5.4-mini-2026-03-17`, `gpt-5.4-nano-2026-03-17`, `gpt-5.2-2025-12-11`, `gpt-5.1-2025-11-13`, `gpt-5-mini-2025-08-07`, `gpt-5-nano-2025-08-07`, `gpt-4.1-2025-04-14`, `gpt-4.1-mini-2025-04-14`, `gpt-4.1-nano-2025-04-14`, `o3-2025-04-16`, `o4-mini-2025-04-16`, `o1-pro`, `o1-pro-2025-03-19`, `o3-mini-2025-01-31`, `o1-2024-12-17`, `gpt-4o-2024-11-20`, `gpt-4o-2024-08-06`, `gpt-4o-mini-2024-07-18`, `gpt-4-turbo-2024-04-09`, `gpt-4-0613`, `gpt-3.5-turbo-0125` | United Arab Emirates: `gpt-5.5-pro-2026-04-23`, `gpt-5.6-luna`, `gpt-5.5-2026-04-23`, `gpt-5.2-2025-12-11` | Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna. Fast mode is not available with EU data residency for GPT-6 Astra or GPT-6 Sol. GPT-6.1 Sol and GPT-6.1 Terra support only US and EU data residency. |

libraries.md +1 −1

Details

173<dependency>173<dependency>

174 <groupId>com.openai</groupId>174 <groupId>com.openai</groupId>

175 <artifactId>openai-java</artifactId>175 <artifactId>openai-java</artifactId>

176 <version>4.91.0</version>176 <version>4.93.0</version>

177</dependency>177</dependency>

178```178```

179 179

models.md +5 −3

Details

10 10

11## Featured models11## Featured models

12 12

~~13- [GPT-6 Astra](/api/docs/models/gpt-6-astra.md): Start here for complex reasoning and coding.~~13- [GPT-6 Astra](/api/docs/models/gpt-6-astra.md): Our most capable model for the most demanding work.

~~14- [GPT-6.1 Sol](/api/docs/models/gpt-6.1-sol.md): Balance intelligence and cost.~~14- [GPT-6.1 Sol](/api/docs/models/gpt-6.1-sol.md): Near-Astra performance for complex work at a lower cost.

~~15- [GPT-6 Luna](/api/docs/models/gpt-6-luna.md): Optimize cost-sensitive, high-volume workloads.~~15- [GPT-6.1 Terra](/api/docs/models/gpt-6.1-terra.md): A fast, efficient model for visual reasoning, precise computer use, and clear, natural writing.

16- [GPT-6 Luna](/api/docs/models/gpt-6-luna.md): Our most efficient model for focused, high-volume tasks.

16 17

17## Browse our full catalog of models18## Browse our full catalog of models

18 19

80- [GPT-6 Luna](/api/docs/models/gpt-6-luna.md): Our most efficient model for focused, high-volume tasks.81- [GPT-6 Luna](/api/docs/models/gpt-6-luna.md): Our most efficient model for focused, high-volume tasks.

81- [GPT-6 Sol](/api/docs/models/gpt-6-sol.md): Built to power complex coding and agentic workflows.82- [GPT-6 Sol](/api/docs/models/gpt-6-sol.md): Built to power complex coding and agentic workflows.

82- [GPT-6.1 Sol](/api/docs/models/gpt-6.1-sol.md): Near-Astra performance for complex work at a lower cost.83- [GPT-6.1 Sol](/api/docs/models/gpt-6.1-sol.md): Near-Astra performance for complex work at a lower cost.

84- [GPT-6.1 Terra](/api/docs/models/gpt-6.1-terra.md): A fast, efficient model for visual reasoning, precise computer use, and clear, natural writing.

83- [GPT-Audio](/api/docs/models/gpt-audio.md): For audio inputs and outputs with Chat Completions API85- [GPT-Audio](/api/docs/models/gpt-audio.md): For audio inputs and outputs with Chat Completions API

84- [GPT-Audio Mini](/api/docs/models/gpt-audio-mini.md): A cost-efficient version of GPT Audio86- [GPT-Audio Mini](/api/docs/models/gpt-audio-mini.md): A cost-efficient version of GPT Audio

85- [GPT-Audio-1.5](/api/docs/models/gpt-audio-1.5.md): The best voice model for audio in, audio out with Chat Completions.87- [GPT-Audio-1.5](/api/docs/models/gpt-audio-1.5.md): The best voice model for audio in, audio out with Chat Completions.

models/all.md +1 −0

Details

12 12

13- [GPT-6 Astra](/api/docs/models/gpt-6-astra.md): Our most capable model for the most demanding work.13- [GPT-6 Astra](/api/docs/models/gpt-6-astra.md): Our most capable model for the most demanding work.

14- [GPT-6.1 Sol](/api/docs/models/gpt-6.1-sol.md): Near-Astra performance for complex work at a lower cost.14- [GPT-6.1 Sol](/api/docs/models/gpt-6.1-sol.md): Near-Astra performance for complex work at a lower cost.

15- [GPT-6.1 Terra](/api/docs/models/gpt-6.1-terra.md): A fast, efficient model for visual reasoning, precise computer use, and clear, natural writing.

15- [GPT-6 Luna](/api/docs/models/gpt-6-luna.md): Our most efficient model for focused, high-volume tasks.16- [GPT-6 Luna](/api/docs/models/gpt-6-luna.md): Our most efficient model for focused, high-volume tasks.

16 17

17## Image18## Image

quickstart.md +1 −1

Details

190<dependency>190<dependency>

191 <groupId>com.openai</groupId>191 <groupId>com.openai</groupId>

192 <artifactId>openai-java</artifactId>192 <artifactId>openai-java</artifactId>

193 <version>4.91.0</version>193 <version>4.93.0</version>

194</dependency>194</dependency>

195```195```

196 196

Documentation 2026-10-25 23:00 UTC to 2026-10-26 23:58 UTC