How to prompt GPT-6 Astra

GPT-6 Astra is the most capable OpenAI offers, and it does not behave like the AI most of us learned on. It asks more questions. It follows written rules very literally. And unless you say otherwise, it fills answers with headings, bullet lists and tables.

None of this is a flaw. Astra takes your instructions seriously, so a clear request matters more than ever. This guide turns OpenAI’s official advice into habits you can use today, mostly in ChatGPT.

The idea in 30 seconds

Pick it for hard work

Save Astra for the hardest, highest-stakes jobs. Try a cheaper model first.

The idea in 30 seconds0:00 / 0:31

Key takeaways

If you remember nothing else, remember these.

Choose Astra for the hardest work. For most everyday tasks, try GPT-6.1 Sol first.
Brief it like a senior colleague: the goal, the limits, the format and what “done” means. Skip the step-by-step recipe.
Tell it when to carry on and when to ask, or it may stop early to check in with you.
Ask for plain paragraphs if you do not want lists and tables everywhere.
Review old saved instructions, such as “always ask me first”. Astra takes them at their word.

Is this model for me?

Most people meet GPT-6 through ChatGPT, not by choosing a model by name. If you are new to writing prompts, start with the AIM method: it matters more than which model answers. Come back here when you want to get more from OpenAI’s top model.

OpenAI released Astra on 3 September 2026 for its most demanding work: complex reasoning, research, coding and long documents. Lighter models followed later in September. Here is how the current three compare, in plain terms.

Model	Best for	Cost
GPT-6 Astra	The hardest problems, costly mistakes	$$$$
GPT-6.1 Sol	Most real work, near Astra’s quality	$$
GPT-6 Luna	Quick, simple jobs in large volume	$

Our recommendation: start with Sol and move up to Astra only when the result is not good enough. OpenAI itself suggests comparing the two on your own tasks. We suggest it for long, multi-step work, for analysis where a mistake is expensive (a funding report, an audit finding, an examiner’s query), and for large sets of documents that need careful reading. For a simple, repetitive job, such as sorting 300 anonymised survey comments into themes, Luna is usually enough. The model hub compares every current model.

One more thing to know: Astra’s is 30 April 2026. It will not know about anything later unless you give it the material or let it search. If you ask about a recent circular or budget announcement, paste the official text into the chat.

In ChatGPT: what you can control

Which model sits behind which ChatGPT option depends on your plan, and it changes often. At the time of writing, OpenAI’s announcements suggest that the everyday GPT-6 experience runs on Sol or Luna depending on plan, and that Astra sits behind a top “Pro” option (not confirmed on an official OpenAI page). Check the model picker in your own account.

The good news: the habits below work whichever model answers.

Put your standing rules first

Think of a good request as a job sheet for a new staff member. The standing rules (who they are, the format, what “done” means) go at the top. Today’s task comes next. The paperwork they need goes at the end, clearly labelled.

Tap a layer, or press Play to see how the AI reads them.

Higher layers outrank lower ones

Your rules sit on top, your request below, reference material at the end. The AI’s answer is checked back against your done criteria.

Layer 1 · You write

Your rules (developer layer)

Who the AI should be, your rules and tone. Put your done criteria and a few examples here too. In ChatGPT, use saved instructions if you have them, or the top of your message. In the API this is the developer message, and it outranks the user message.

Layer 2 · You write

Your request (user message)

The specific job for today. In ChatGPT, this is what you type.

Layer 3 · Pasted material

Reference material in tags

Documents, data and notes wrapped in tags such as <abstracts>…</abstracts>, placed near the end so the AI can tell material apart from instructions.

Layer 4 · The AI writes

The AI’s answer

Judged against your done criteria. Ask the AI to check its own work, then check it yourself.

The check

Checked against done criteria

The answer goes back to what you wrote in layer 1.

Done criteria: deliverable, format, how to verify, when to stop or ask.
Examples: a few varied input and output pairs.

How a strong request is layered. In ChatGPT, the top layer is your saved custom instructions or the first lines of your message; the middle is today's request; pasted material goes last, wrapped in labels.

Wrap pasted material in simple labels, such as the word “notes” in angle brackets before and after it. These are called , and they stop the AI mixing up your data with your instructions. Two or three varied of what you want often teach more than a paragraph of description.

Give the goal, not every step

OpenAI compares a reasoning model to a senior co-worker. You would not hand a senior accountant a 12-step recipe for checking a ledger. You would say what you need, by when, in what form, and how you will judge it. Do the same with Astra.

A precise action verb states the goal sharply: “reconcile”, “rank”, “rewrite”. If you are not yet sure what you want, the Chris Voss method turns the request into a short dialogue first.

Say what “done” looks like

Astra is more likely than older models to stop and ask when it thinks more input could change the result. It can also pause for review while work remains. The fix is a “done contract”: a few lines that say what the finished result is, its format, how to check it, and when to stop or ask.

For example, an accounting lecturer asking for a rubric might add: “Done means five criteria, four levels, every cell filled, and weights that total 100%. Check that each criterion measures . If a detail is missing, assume sensibly, note it at the end and keep going.” Four sentences, and the most common reasons for a half-finished answer are gone.

Try it below. Pick a task and tap each part of the contract to see which problem it prevents.

Interactive

Tell the AI what “done” looks like

Pick a task. Then tap each part below to add it to the prompt, and watch the risk list turn green.

Parts of a “done” brief

Tap a part to add it. Tap again to remove it.

Your prompt

I teach Principles of Marketing (Diploma Year 1). CLO2: Present a marketing-mix (4P) proposal for a local SME product. Our faculty scale is Excellent (4), Good (3), Satisfactory (2), Weak (1).

Create a marking rubric for the CLO2 group presentation.

Risks covered: 0 of 5

Start with any part. The base request on its own leaves all five risks open.

Stops too early
Too many questions
Too much formatting
Nothing checked
Wasted time or cost

Leave out you do not need. A line like “stop after the first draft so I can check” pulls Astra towards stopping early. If the task is clearly yours to approve, tell it to work out what you mean, carry on, and bring you something concrete before asking for approval.

Ask for plain paragraphs

Astra leans towards : headings, bullet lists and tables. That is fine for a report outline, but not for an email. If you want prose, ask for clear, short paragraphs, plain language, lists only when items are truly parallel, and no closing summary.

Can you look at this month's budget variance and write something for my head of department?

What you typically get back

Astra may ask three clarifying questions first. Or it returns a formatted report with headings, a variance table, a risk section and a closing summary, when you needed one short paragraph.

You are a senior finance officer at a Malaysian polytechnic who writes short, plain memos.

This month's budget-versus-actual table is inside <variance> tags. My notes on the reasons are inside <notes> tags. The reader is my head of department, who reads on a phone.

Write a memo paragraph. Done means one paragraph under 150 words naming the three largest variances in RM, each with the reason from my notes. Recalculate each variance from the table before you finish. Do not ask questions first; if a reason is missing, write "reason not yet confirmed". No headings, tables or bullet lists.

What you typically get back

One paragraph you can paste straight into a message, with figures you know were rechecked and gaps clearly marked.

Watch your saved instructions

Astra follows long instructions well, but it takes standing instructions very literally. If your ChatGPT custom instructions or saved memory say “always ask me before you start”, it may halt work it could safely finish. Rewrite old rules so they say when to ask, not “always”.

The same goes for detailed recipes written for older models. OpenAI’s Astra blog warns that guidance written for its other models, such as the older GPT-5.6 Sol, can overconstrain Astra. Our reading: trim long, scripted prompts down to the goal, the limits and the finish line.

Tell it which checks matter

Astra checks its own work thoroughly without being asked, sometimes more than a small task needs. Say which checks matter (“recalculate every total”; “confirm every ID exists”) so it spends its effort where it counts.

Three small habits that save time

Name your attachments. “Use only the file Draft_S3.docx” stops it mixing sources when several files are in the chat.
Start a fresh chat for a new task, so old instructions and earlier files do not leak into the answer.
Ask for assumptions at the end. “Note any assumptions in one line at the end” gives you a quick list to check instead of a round of questions.

Thinking levels: a quick glance or a full audit

Some ChatGPT plans let you choose how long the model “thinks” before it answers. Developers call this . Think of an auditor. A quick glance at a receipt takes seconds. A full audit of the year’s accounts takes days and costs far more. Both are useful, for different jobs.

Match the thinking level to the job

Quick glance

Reformatting, short replies, simple follow-ups.

Match the thinking level to the job0:00 / 0:26

The names of the levels depend on your plan. OpenAI’s announcements appear to list options such as Instant, Medium, High and Extra High (not confirmed on an official OpenAI page). OpenAI’s own guidance treats this setting as a tuning knob, not the main way to rescue a weak prompt.

Ready-to-copy prompts for local work

Each prompt includes a done contract. Replace the details in the Input with your own, and remove personal data first.

Lecturer: draft feedback

You are an experienced lecturer in a Malaysian polytechnic who gives fair, encouraging and specific feedback.

The rubric for CLO3 is inside <rubric> tags. Five anonymised student drafts are inside <draft id="S1"> to <draft id="S5"> tags. Students are Diploma Year 2, writing in English as a second language.

Write feedback for each draft. Done means five sections, one per draft ID, each with two strengths and two improvements tied to named rubric criteria, under 120 words, in plain paragraphs. Do not award marks; I will do that. Do not ask questions first. If a draft is too short to judge a criterion, say so instead of guessing.

Accounting: trial balance check

You are a careful accounting lecturer who teaches a diploma course on financial accounting.

A student's trial balance is inside <tb> tags and the ledger balances it came from are inside <ledger> tags. The trial balance is out by RM1,240.

Find the likely causes of the difference. Done means a short list of up to five candidate errors, each with the accounts involved, the amount and why it would explain all or part of RM1,240, ranked from most to least likely. Recalculate both column totals before you start. Do not correct the student's work; I will use your list to give hints. If no single error explains the full amount, say so.

Office: meeting minutes

You are an experienced administrative officer who writes clear, neutral minutes.

My rough notes from today's programme meeting are inside <notes> tags. Attendees are listed at the top by role only.

Turn the notes into minutes. Done means four parts: attendees by role, decisions made, action items (each with owner role and due date), and open issues. Use only what is in my notes; write "not stated" where a due date is missing. Plain sentences, one short list for action items, no other formatting. Do not ask questions first.

Penang plant: downtime

You are a continuous-improvement engineer at an electronics plant in Penang.

This week's shift logs for SMT lines 1 to 4 are inside <logs> tags. The reader is the plant manager, who reads on a phone between meetings.

Write a downtime summary. Done means a short paragraph on the overall picture, the three biggest causes of downtime ranked by minutes lost with the line and shift for each, and one recommended action per cause. Recalculate every total from the logs before you finish. Keep it under 250 words, in plain sentences, with no table. If a log entry is unclear, list it at the end rather than ask me.

Ask Astra to review your old prompts

OpenAI’s most practical tip: rather than reviewing every old prompt yourself, ask Astra to do it against this guidance.

Review an old prompt

You are a prompt reviewer who knows OpenAI's guidance for GPT-6 Astra.

My current prompt (or my ChatGPT custom instructions) is inside <prompt> tags below. I use it for: marking feedback on diploma assignments.

Review it against these points: a clear goal and output format; a stated definition of done and how to check it; no unnecessary review stops or "always ask first" rules; no rigid step-by-step recipe; formatting instructions if I want prose; no contradictions. Return the revised prompt first, then at most five one-line notes explaining the biggest changes.

For developers: technical detailsOptional: skip this if you only use the chat app

Naming. You may see the model written as “GPT Astra 6”. The official name is GPT-6 Astra, and the API model ID is gpt-6-astra (currently the only snapshot).

Lineup and price (standard API rates per million tokens, from OpenAI’s model pages, checked 12 October 2026):

Model (API release)	Input / output
`gpt-6-astra` (3 Sep 2026)	US$10 / US$50
`gpt-6.1-sol` (29 Sep 2026)	US$2 / US$10
`gpt-6-luna` (22 Sep 2026)	US$0.10 / US$0.50

All three take text and image input and produce text. Context window about 1.05 million tokens, up to 128,000 output tokens. Prompts over 272,000 input tokens are billed at higher rates for the whole request.

Layers. In the API, rules go in the instructions parameter or a developer message, which outranks the user message. A typical order is identity, instructions, examples, then context, with reference material in XML-style tags near the end.

Settings that matter for Astra:

Use the Responses API for tools. Chat Completions works with Astra for requests without tools, but tool calling needs Responses.
Reasoning effort accepts low, medium, high, xhigh and max. Astra rejects none; use low instead. If you used minimal with an older model, start with low and compare. (GPT-6 Luna accepts none.)
Remove sampling settings. With reasoning on, which is always the case for Astra, remove temperature, top_p and top_logprobs (and logprobs in Chat Completions).
Change effort mid-conversation with a configuration_update input item instead of changing the request-level effort, so the start of your prompt stays cacheable. OpenAI describes this for standard, single-agent requests.
Order for caching. Put stable instructions and examples first and changing material last. Keep prompts in version control with evaluations, and pin the model snapshot.

Skills and AGENTS.md. Astra takes skills and AGENTS.md files (the standing instruction files that agent tools read) more literally than earlier models. OpenAI’s advice: state that the user’s instructions take precedence over a skill; audit skills and instruction files for stale or conflicting rules; and point to specific documents with a trigger (“for schema changes, read the schema guide”) instead of “read every document before any edit”. Keep skill descriptions short, and make a large skill’s main file a short index that points to supporting documents. If instruction files are shared by agents on different models, think about which models will read them.

Sub-agents and tests. Astra may delegate less than you want, so say when and how much to parallelise. It also tests thoroughly on its own: remove old “always test everything” rules and allow it to skip tests for low-impact, easily reversed changes.

{
  "model": "gpt-6-astra",
  "reasoning": { "effort": "medium" },
  "instructions": "Identity, rules, done criteria and examples.",
  "input": "Today's request, then reference material in tags."
}

Check your understanding

Sources

Using GPT-6 (OpenAI API docs) (opens in a new tab)developers.openai.com
Rethinking skills and prompts for GPT-6 Astra (OpenAI developer blog) (opens in a new tab)developers.openai.com
GPT-6 Astra model page (opens in a new tab)developers.openai.com
GPT-6.1 Sol model page (opens in a new tab)developers.openai.com
GPT-6 Luna model page (opens in a new tab)developers.openai.com
Prompt engineering guide (opens in a new tab)developers.openai.com
Reasoning models guide (opens in a new tab)developers.openai.com
OpenAI API changelog (opens in a new tab)developers.openai.com

Nice work!

Guide complete

You made it to the end. Take the quiz above if you have not yet, for bonus XP.

0 XP
0 day streak