OpenAI's latest model, GPT-6 Astra, processes over a million tokens in a single task, controls a computer, browses the web, writes code, and creates documents. Astra requires fewer supporting instructions than its predecessors, but it needs much clearer prompts. Old commands that forced weaker models to act now cause unnecessary testing or premature stopping.
Basic information about Astra
The model runs under the designation gpt-6-astra. In ChatGPT, it is available on the Plus, Pro, Business, and Enterprise plans, and it can also be accessed through the OpenAI interface and Amazon Web Services cloud services. One million input tokens cost ten dollars, while one million output tokens cost fifty. The context window holds 1,050,000 tokens, and the maximum response is 128,000 tokens. Anything that does not fit within this limit is cut off by the system. Tool calls work only through the Responses API, not through the older Chat Completions.
OpenAI also mentions a new reasoning method called recurrent depth. The model processes the task internally before it begins generating a response, so the path to the result is less visible than before. If you need an output you can rely on when making decisions, divide the work into individual steps and request justification.
Tell the model when not to ask
Astra asks for clarification more often than older models. It does so in situations where missing information could substantially change the result. This is useful if a wrong assumption could cost a lot of money. At the same time, it is annoying when it concerns a routine detail for which you expect the system to infer the missing information.
Developers recommend setting a rule for autonomy before starting a long task. Include an instruction in the prompt telling the model to infer the intent and scope from the text and previous conversation. It should move forward, make reasonable assumptions, work independently toward the goal, and stop for confirmation only when the next step is destructive or irreversible.
The way you speak to the model also plays a role. Phrases such as could you or I would like may sound polite, but the system may interpret them as tentative suggestions. If this keeps happening, add a permanent note to the AGENTS.md file stating that these phrases constitute permission to act.
Organize your instructions before blaming the model
Astra can handle long instructions, but it is more sensitive to directions that overlap or contradict one another. Clutter in the AGENTS.md file and too many defined skills then manifest as hesitation by the system, even though the cause lies in your documentation.
A useful audit is not about shortening things. Have the model find contradictions in rules concerning autonomy, approval, questioning, and completion of work. These four areas are responsible for most unexpected stops. Add an important safeguard requiring the model to distinguish genuine approval instructions from wording that only occasionally obstructs routine work. The system should also flag any change that would expand its permissions. Have it submit proposed edits for approval only, rather than applying them immediately.
Apply the same logic to permanent rules in the repository. Instructions in AGENTS.md apply to every activity in the project, so every line is a permanent tax. An instruction telling the model to read the documentation first makes sense for a major overhaul but causes delays when fixing a typo. An unconditional command to run all tests then generates extra work because Astra verifies changes on its own.
Define what done means
Developers warn about the opposite extreme as well. Astra reaches the first working solution and immediately asks for feedback, even though the work is clearly not finished. Help the model define the goal in advance. A task is complete only when the system has made the requested change, checked the result, fixed any errors it caused, and verified the final state. It should complete these steps without requesting a review unless it encounters a decision that changes the scope of the work, has an irreversible impact, or requires information that cannot be safely inferred.
Developers also warn against automatically carrying over old instructions to stop and check. A boundary that made sense for a previous model will now cause Astra to stop prematurely.
Testing should match the risk of the change
Older programming models had to be forced to test, but Astra is different. A small, reversible change can trigger verification that the task does not warrant because the system takes completion criteria too seriously. If the permanent instructions include a command to continuously run the entire test suite, it will do so even for a single inconsequential line.
Set a boundary based on risk. For a purely visual adjustment, such as moving a button in a pricing table by a few pixels, it is enough to inspect the affected section at common screen sizes, and you do not need to write new tests. A change to restoring an authenticated session, by contrast, must pass tests, verify both login and logout, check behavior at protected URLs after refreshing the page, examine the state after expiration, and list anything that could not be verified.
Repeated safe operations are a special case. Vague requests to ask before continuing will stop the system even in the middle of a routine process. Authorize a specific loop instead of weakening approval requirements across the board. If local tests use temporary data and have no access to production, state this in the documentation and instruct the system to run them, fix errors, and repeat the tests without asking about every step.
Clearly state which instruction to use and when
Astra does not load the full text of all installed skills. It sees only their names and descriptions, retrieving the detailed instructions only when it decides to use a particular skill. A problem arises if it uses, say, five of them for a task that requires only one. Each takes up context space, and overlapping instructions pull the system in different directions. One tells it to continue, while another requires it to stop and discuss the plan.
Therefore, create a short main skill file that serves as a directory. It should contain only the minimum information the system needs to recognize when the skill is suitable and when to use it. Procedures, scripts, and other materials belong in separate files that are loaded only when needed. Also watch out for descriptions that try to stand out and sound relevant to any adjacent task. If there are many skills with long descriptions, the system may shorten them to make them fit, making decision-making worse. If the model repeatedly stops without explanation, ask it which instruction caused it.
Reasoning effort: start at medium
Astra offers five reasoning levels, from lowest to maximum, and does not support a zero level. According to OpenAI's recommendations, anyone migrating from an older configuration with zero or minimal reasoning should start at the low level and compare the results.
For ordinary coding work, the medium level with planning enabled works well. Higher settings exist for good reason, but enabling them immediately usually does not justify the time and money they consume. Stay at the medium level until you have evidence that it is insufficient, such as an error the system failed to resolve after a genuine attempt. Then give it specific evidence, such as steps to reproduce the error, error messages, and an overview of what you have already tried. A typical example is a form that reports a successful save, but the data disappears after the page is refreshed. Instead of increasing the reasoning level, tell the system to trace the save process and find where the value is lost before it touches the code.
Instructions in the prompt to think as deeply as possible do not work. Reasoning effort is an interface setting, not a matter of how the task is phrased.
Prompt structure and working with long context
For longer tasks, it is helpful to divide the prompt into blocks, each corresponding to one risk. These sections include the goal, context, requirements, boundaries, instruction hierarchy, autonomy, tools, delegation, output, verification, and stopping condition. For a typical task, however, the task, context, requirements, and output are sufficient. A prompt is not better because it is longer, but because each block prevents a specific problem that could arise in your work. If a particular risk does not apply, simply remove the block.
The hierarchy of authority deserves attention whenever multiple sources of instructions are involved in a task. Application instructions, the user's request, the AGENTS.md file, skills, project documentation, tool descriptions, and loaded content together create room for conflict. The solution is not to add more instructions but to clearly establish which source has the final say and remove anything that no longer applies. Loaded web pages, uploaded documents, and tool results fall into the category of data, not instructions, unless you explicitly assign them instructional authority.
One million tokens means an entire repository and a collection of documents can fit into a prompt. At the same time, however, this makes it tempting to load absolutely everything into the context. Therefore, specify which sources are authoritative and which are merely supporting material, how conflicts should be resolved, and whether older context should be considered outdated.
Visual design, browser testing, and subagents
A prompt such as make a modern dashboard leaves almost every visual decision open. It is better to give the system visual references and specify exactly what it should take from each one. This might be a compact table from one reference and the typography and spacing from another, while the colors should adhere to the existing brand identity. The references must match the type of screen you are building. A screenshot of a promotional page tells you nothing about how to handle a table with a hundred rows. Once the page is complete, have the system compare it with the reference and correct the biggest discrepancies in spacing, typography, and mobile display.
Similarly, provide specific instructions for browser testing, which Astra handles well. Describe the actual flow in which the system opens the application, completes the main task using a test account, tries both an empty form and an invalid value, verifies that data persists after the page is refreshed, and checks the display on mobile devices. Also request a short list of the elements tested, errors, and unverified items. Address speed separately and measure it under the same conditions. Comparing the initial run before a change with a cached load afterward creates the appearance of an improvement that does not actually exist.
Astra can divide work among subagents, but it does so less often on its own than people expect. An instruction to use subagents is weak; a strong prompt must describe the conditions precisely. The system should divide independent work when parallel execution will save time or improve coverage without creating conflicting edits. Suitable tasks include researching competitors by segment, independently exploring a repository, or analyzing separate datasets. Do not delegate work that requires a step-by-step process, minor tasks where coordination is inefficient, or concurrent modifications to the same part of the code. The main agent is then responsible for reconciling conflicting findings based on the authority and recency of the source, rather than averaging the conclusions.
Where errors most commonly occur
The most common problems with Astra have nothing to do with the prompt. The user often does not have a plan that provides access to this system, or accidentally leaves an older model selected in the menu. This is usually the main reason the system appears to ignore instructions. Another group of problems arises from limits. An excessively large prompt overwhelms the context window, a response exceeding the specified limit is cut off, and complex tasks incur higher costs. According to OpenAI, Astra is also the first system to reach a critical level of cybersecurity capabilities in its evaluations, so some features remain locked.
A new prompt cannot be evaluated simply by reading it. Changes tailored to Astra modify behavior, not content, and can easily replace one problem with another. An instruction encouraging greater autonomy will reduce the number of unnecessary questions but increase the number of incorrect assumptions. A stricter testing rule will reduce errors but increase waiting time. Therefore, create a set of typical tasks, run both the old and new prompts on them, and compare success rates, instruction compliance, tool behavior, the number of unsolicited questions, response time, and cost.
Sources: theneuron.ai, promptessor.com, mindstudio.ai and layer3labs.io
