AI Catchup

Prompting GPT-6 Astra and GPT-6.1 Sol: Effort, Migration, and Prompts That Keep It Working

By 11 min read

GPT-6 Astra follows instructions more closely than earlier OpenAI models and asks more questions, so prompting it is mostly removing old scaffolding: grant permission to finish, trim skills and AGENTS.md, and stop ordering tests. In the API, replace none effort with low, move tool calls to Responses, and switch caching to prompt_cache_options.ttl.

GPT-6 Astra needs less prompting than GPT-5.6, not more. OpenAI says Astra is stronger at instruction following and more sensitive to instructions in skills and files such as AGENTS.md, and it is more likely to stop and ask. Most of the work is deleting instructions written for weaker models and telling Astra plainly when a task is finished. This guide distills OpenAI's Using GPT-6 guide and its skills and prompts post for Astra.

For the models themselves, see our coverage of the GPT-6 Astra launch and GPT-6.1 Sol. For cross-model fundamentals, start with our prompt engineering playbook.

Key Takeaways

  • Replace none effort with low. GPT-6 Astra and GPT-6.1 Sol reject none; Astra answers it with an HTTP 400 error.
  • Set Astra's effort explicitly. OpenAI lists Astra's effort values but does not document a default.
  • Move tool calls to the Responses API. Astra and GPT-6.1 Sol accept Chat Completions requests, but tool calling requires Responses.
  • Switch prompt caching to prompt_cache_options.ttl. Coming from GPT-5.5 or earlier, it replaces prompt_cache_retention.
  • Grant permission to finish. Astra asks more questions than earlier models; tell it which work needs no approval.
  • Audit skills and AGENTS.md. Astra takes them more literally, so cut long descriptions, recipes, and test mandates, and soften ask-first language.
  • Define completion up front. Astra may return after a first implementation unless you say what done means.

Which GPT-6 Model and Effort to Use

Start on GPT-6.1 Sol for coding agents and move a task to GPT-6 Astra only when your own evals show the gap is worth it. OpenAI describes GPT-6.1 Sol as near-Astra performance at a lower cost. Use GPT-6 Luna for focused, high-volume work. The API constraints differ by model:

GPT-6 AstraGPT-6.1 SolGPT-6 Luna
Model IDgpt-6-astragpt-6.1-solgpt-6-luna
Effort valueslow, medium, high, xhigh, maxlow, medium, high, xhigh, maxnone, low, medium, high, xhigh, max
Default effortNot documentedmediummedium
Tool calls in Chat CompletionsNo, use ResponsesNo, use ResponsesOnly with reasoning_effort: "none"
Fast mode with EU data residencyNoYesYes
Ultrafast data residencyUS and global processing onlyUS, EU, and global processingNot listed for Luna
Input / output per 1M tokens$10 / $50$2 / $10$0.10 / $0.50

Sources: OpenAI's GPT-6 Astra, GPT-6.1 Sol, and GPT-6 Luna model pages, the reasoning guide, and the Ultrafast guide.

Two details catch teams out. Astra's default effort is absent from its model page, the GPT-6 guide, and the reasoning guide, which gives medium as the default only for the other GPT-6 models: GPT-6.1 Sol, GPT-6 Sol, and GPT-6 Luna. Set reasoning.effort on every Astra request. And Fast mode for GPT-6 Astra does not include a latency SLA, so do not plan an EU or latency-bound deployment around Astra Fast.

Migrating From GPT-5.6 or GPT-6 Sol: The API Checklist

The migration is seven checks, and OpenAI's own Codex skill can apply them for you. Work through them in this order:

  1. Change the model. Set model to gpt-6-astra, gpt-6.1-sol, or gpt-6-luna.
  2. Fix effort. On Astra and GPT-6.1 Sol, replace none with low. If you used minimal, start with low and compare results on representative tasks. The field is reasoning.effort in Responses and reasoning_effort in Chat Completions.
  3. Move tool calls to Responses. Astra and GPT-6.1 Sol support Chat Completions only without tools.
  4. Drop sampling parameters. When effort is not none, remove temperature, top_p, and top_logprobs. In Chat Completions also remove logprobs; in Responses remove message.output_text.logprobs from include.
  5. Update caching. Coming from GPT-5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl set to "30m". That value is the only one supported and the default, and a cached prefix stays reusable for 30 minutes after its last write or reuse. Budget for cache writes, which cost 1.25 times the uncached input rate on GPT-5.6 and later.
  6. Change effort without breaking the cache. If you raise or lower effort between turns, add a configuration_update input item and leave request-level reasoning.effort alone. OpenAI supports this in standard, single-agent mode, and it changes only reasoning effort.
  7. Let Codex do it. OpenAI's guide gives a one-line Codex prompt, $openai-docs migrate this project to the GPT-6 model family, which uses the OpenAI Docs skill. You can download the same skill for other coding agents.

If you are still on gpt-5.6-sol and depend on none effort, it remains a live model that accepts none; our GPT-5.6 prompting guide covers it.

Why Astra Stops to Ask, and How to Keep It Working

Astra asks more because it is designed to. OpenAI says the model is more likely to ask a question when extra input could materially change the result, which can make it stop where you expected it to make reasonable assumptions and persist. Fix this with permission, not pressure.

OpenAI's guide offers three starting prompts, which you should copy from the initiative and follow-through section and adjust:

  • Infer intent and persist. Tell the model to work out the task's scope from the conversation, then keep going until the goal is met, taking reversible steps such as worktrees, merge-conflict fixes, and draft PRs on its own. OpenAI's version tells it to "bias towards action and carry the user's intended task to completion."
  • Treat requests as instructions. A request phrased as a question about ability should start the work, not end with a plan, an offer, or a partial answer.
  • Approve results, not intentions. Ask the model to finish everything already authorized so your approval is the last step before a deploy, merge, or publish, and to skip unsolicited warnings and checklists about hypothetical risk.

Tune all three to the autonomy your product allows. A customer-facing assistant may want the questions; a coding agent in a disposable worktree usually does not.

Define Completion Before You Start

Say what done looks like in the request itself. OpenAI's skills post warns that Astra can reach a first implementation and come back for review while work remains, and that a rule to stop for review after the first implementation pulls it toward stopping early. If the job includes running the result, inspecting it, and fixing what fails, put all three in the request.

Thomas Ricouard's architectural visualization post shows the shape. His request asked Astra to back up the scene, build the larger house in Blender, and keep iterating until the house, furniture, and garden were detailed and the geometry was correct, with the Unreal Engine 5 export as the named next step. That is a finish line, not a first draft. If you want exploration beyond a first pass, say what to explore and where to stop.

Skills and AGENTS.md: Audit What Astra Now Takes Literally

Audit every skill and instruction file your agent can read. OpenAI's guide says Astra can be more sensitive to instructions in skills and AGENTS.md, and that unclear or conflicting guidance in a skill can make it pause and block work early. OpenAI's skills post gives the specific cleanups:

Old habitWhat to do for Astra
Long skill descriptions that trigger on a whole domainKeep descriptions as short as possible and say exactly when the skill applies. A migration skill should fire when you add or change a migration, not whenever you touch a database.
One long SKILL.md covering several workflowsMake the root file a minimal router that points to supporting docs and scripts, so the model reads only what the task needs.
Step-by-step recipesCut them back. Overly specific guidance can now hinder results, and guidance written for Sol or Luna may overconstrain Astra.
An AGENTS.md rule to read several docs before every editPoint to each doc by situation: one for service boundaries, one for schema changes, one for deployments.
"Always run the tests"Remove it. Astra checks its work on its own, so the old line can cause unnecessary testing.
Strong ask-first language for older modelsSoften it, and grant explicit permission for workflows you know are safe, such as a local test suite on disposable fixtures.

The skills post also notes that when you load too many skills, Codex starts shortening their descriptions to fit, so the model sees less of each one. Fewer, sharper skills beat a large library.

Two prompts from OpenAI's guide help when instructions still collide. State that the user's explicit instructions take precedence over a skill's guidelines. And ask the model, whenever a skill makes it pause, ask permission, or leave work unfinished, to name and link the exact SKILL.md file, quote the instruction, and say whether it is an explicit requirement or its own interpretation. That second prompt is the fastest way to find the silent conflicts in a large instruction set.

Writing Style and Formatting

Specify the output style you want, because Astra's default leans on lists, tables, and Markdown. OpenAI's guide says the model tends toward detailed, formatted responses and may reuse phrases across sessions. Its suggested prompts ask for concise paragraphs with one idea each, lists only for parallel or sequential items, the main point stated early, plain verbs over jargon, and no stock phrases or contrastive framing that introduces an alternative nobody asked about. Copy the full blocks from the writing style section.

Subagent Delegation

Tell Astra when to delegate, because it may do so less often than your harness expects. OpenAI says GPT-6 Astra is trained to divide work across parallel subagents and responds well to prompting about how and when to do it. Its sample prompt tells the model to delegate whenever parallel work would save time or improve quality, whether it is the root agent or a subagent. A second prompt asks for legible inter-agent messages with proper spacing, since messages between agents can contain grammar or spacing errors. For delegation patterns on the Claude side, see our subagent patterns guide.

Testing Without Over-Testing

Calibrate testing to the change instead of ordering more of it. OpenAI says that for coding tasks Astra tends to test thoroughly before calling a task complete, which can mean broader tests than a small task needs. Its suggested prompt says not to write tests for reversible, low-impact changes that mirror the implementation, to run the checks the change requires, and to broaden testing only when new changes, failures, or open concerns justify it.

For larger projects, give the model tools to verify with rather than instructions to verify more. In OpenAI's games post, the Void Explorer game exposes a small JavaScript state interface, window.__VOID_EXPLORER__, plus named test scenes for orbit, travel, descent, and landing that Playwright can load and check. Ricouard says he would build those tools early in his next game, because they let Astra investigate and test changes independently.

New API Features Worth Adopting

GPT-6 adds four capabilities that change how you build agents, beyond the prompting changes above:

  • Async tool calling. Set async: true on a function or custom tool, and the model keeps reasoning or answers other parts of the request while your application runs the tool. Return the result with the original call_id.
  • Mid-turn steering. Send a correction or new requirement while the model is working. Over a WebSocket connection, the Responses API keeps completed work and folds the update into a continuation.
  • Reasoning changes that keep the cache. The configuration_update item from the checklist above lets you raise effort for a hard step and lower it for routine follow-ups.
  • Misalignment monitoring. For Astra, OpenAI says its systems asynchronously monitor for misalignment and trigger alerts when necessary.

For raw speed, Ultrafast mode for GPT-6 Astra and GPT-6.1 Sol is available to all API users: set service_tier to ultrafast. On GPT-6.1 Sol, Ultrafast costs 6x Standard. Our Pro 500 and Astra Ultrafast coverage covers the ChatGPT side.

Sources

Read next

More practices and workflows

Frequently Asked Questions

Does GPT-6 Astra support reasoning effort none?

No. Setting none on GPT-6 Astra returns an HTTP 400 error, and GPT-6.1 Sol rejects both none and minimal. OpenAI's migration guide says to use low instead. GPT-6 Sol and GPT-6 Luna still accept none, so check which model each request targets.

What is GPT-6 Astra's default reasoning effort?

OpenAI does not state one. The Astra model page lists low, medium, high, xhigh, and max, while the reasoning guide gives medium as the default only for the other GPT-6 models: GPT-6.1 Sol, GPT-6 Sol, and GPT-6 Luna. Set effort explicitly on every Astra request rather than relying on an omitted value.

Why does GPT-6 Astra keep asking for permission?

OpenAI says Astra is more likely to ask when extra input could change the result, and it can stop where you expected it to assume and continue. Tell it to infer intent, finish reversible work without asking, and save approval for a concrete, reviewable result.

How should I change AGENTS.md and skills for GPT-6 Astra?

Audit them. Astra is more sensitive to instructions in skills and AGENTS.md, so shorten skill descriptions to when the skill applies, turn long skills into routers, point to docs by situation instead of before every edit, and soften test and ask-first rules written for older models.

Can I use tool calling with GPT-6 models in Chat Completions?

Not with GPT-6 Astra or GPT-6.1 Sol: both support Chat Completions, but tool calling requires the Responses API. GPT-6 Sol and GPT-6 Luna allow function calling in Chat Completions only with reasoning_effort set to none. Move agent loops to Responses.

Get the weekly AI Catchup

Tools, practices, and what matters, in your inbox every week.