GPT-6 Astra: Practical Manual to Maximize Codex, Agents, and Costs

Objective:

learn to distribute Luna, Terra, Sol, and Astra intelligently to maximize performance, reduce costs, and keep agent workflows running for long periods.

OpenAI's GPT-6 Astra, announced on September 3, 2026, represents a major leap in the ability of agents to perform complex computing tasks that previously required considerable human intervention.

But the real challenge is no longer simply asking "can Astra do this task?".

The important question now is:

Where does Astra truly add value, how should we allocate our resources, how can we keep agents working longer, and how do we achieve all this at the lowest possible cost?

This article is primarily aimed at those who use Codex and programming agents on a regular basis, especially in near-production environments.

Target audience

This manual is designed for people who:

• Use agents via Codex or the OpenAI API in near-production environments.
• Want to alternate between Luna, Terra, Sol, and Astra to reduce monthly API or infrastructure costs.
• Want to build long-running workflows for: exhaustive debugging, large refactorings, computer tool utilization, mathematical verification, automated testing, and tasks that require maintaining context for a long time.

0. Prerequisites

Deployment, Enterprise, Daybreak, and Availability

Before attempting to optimize Astra, you must first check that the model is actually available for your account and environment.

Announcement date

September 3, 2026 — official announcement

OpenAI — GPT-6 Astra

Deployment

According to official announcements, Trusted Access/Daybreak will be one of the first deployment channels.

Plus, Pro, Business, and Enterprise plans, as well as the API and AWS, would be deployed later.

In enterprise environments, the administrator may need to explicitly enable access.

Important points

• Enterprise: the administrator must enable it when applicable.
• Free tier: Astra is not planned as a free model.
• Credits: users of paid plans may have additional credit options depending on the product.
• Cybersecurity: some advanced capabilities may be conditional on specific access paths like Daybreak.
• API model ID: gpt-6-astra.

Standard API Price

According to the rates indicated in this document:

• Input: $10 / million tokens.
• Output: $50 / million tokens.

There are different rates and conditions for certain modes, long contexts, caching, and priority processing.

Fundamental rule:

just because Astra does not appear in the interface does not necessarily mean the model does not exist for your organization. First check availability, permissions, and deployment.

While verifying access, the strategy can be built using Sol as the base model.

1. Where does Astra excel and where is Sol enough?

Astra is designed as a high-end model for professional tasks, especially those related to:

• computer use,
• browsing,
• software engineering,
• agents,
• science,
• mathematics,
• complex end-to-end tasks.

Official documentation positions high-end models for the hardest end-to-end jobs.

The correct strategy, however, is not to use Astra for absolutely everything.

The correct strategy is:

Use Astra only when its higher capacity has a real impact on the outcome.

1.1. Where does the difference really appear?

The most important differences tend to appear in tasks where several factors combine:

• multiple files or modules,
• many consecutive steps,
• intensive use of tools,
• interaction with graphical interfaces,
• hard-to-reproduce problems,
• mathematical reasoning,
• prolonged debugging,
• high cost of making a mistake,
• loss of context,
• need to maintain a strategy for a long time.

In everyday and simple tasks, the difference can be much smaller.

Therefore, a good rule is:

Don't ask which model is "better". Ask which model is cheaper to complete this task correctly.

1.2. OSWorld, Mind2Web, and the question of speed

Benchmarks like OSWorld and Mind2Web are useful for understanding differences between models, but they must be interpreted correctly.

In the OSWorld 2.0 latency simulations mentioned in the official documentation, Astra achieved higher processor utilization than Sol and showed approximately 47% less time per task in the comparison indicated.

For example:

• Astra: approximately 40 minutes.
• Sol: approximately 75 minutes.

The indicated score was approximately:

• Astra: 72.6%
• Sol: 65.7%

Likewise, the documentation indicates that Astra + the new Codex harness can be approximately 1.9× faster than the current Sol experience in certain Mind2Web tests.

But remember two things

1. It's a benchmark.

A 1.9× result on Mind2Web does not mean that every internal task in a company will be 1.9× faster.

2. It does provide a useful signal.

The more a task depends on:

• screens,
• tools,
• navigation,
• multiple actions,
• intermediate decisions,

the more sense it makes to evaluate a combination of model + agent system, rather than just comparing tokens per second.

1.3. When is Sol enough?

Use Sol, Terra, or Luna first when:

• the answer can be completed in a single exchange;
• you only need to modify one or two files;
• tests are short;
• the task is primarily reading;
• no GUI is required;
• no complex tools are needed;
• the cost of repeating the work is low;
• a failure does not generate major consequences.

Astra begins to make sense when the opposite occurs

For example:

• many files;
• multiple modules;
• long tool chains;
• computer use;
• complex debugging;
• mathematical verification;
• tasks where a failure implies a lot of rework;
• loss of context during a long session.

2. ChatGPT, API, and Codex Configuration

2.1. ChatGPT: select Astra

When Astra becomes available:

1. Open ChatGPT on Web or Desktop.
2. Check the model selector.
3. Select Astra / GPT-6 Astra.
4. If you use Codex, check that the same model is available there.
5. If Astra does not appear: check the plan; check enterprise permissions; verify deployment; use Sol as a temporary configuration.

Pro, Business, and Enterprise plans may include specific variants of Astra. You should not draw conclusions solely from the name displayed in the interface: always review the description corresponding to the plan.

2.2. API: model = "gpt-6-astra"

The basic configuration consists of specifying the model in the Responses API.

Important considerations

• For tool calls, preferably use Responses API.
• Astra does not support reasoning.effort = "none".
• If you use a low level of reasoning, start with a small configuration and increase only when necessary.
• Some traditional parameters, such as temperature or top_p, may not be available.
• Data residency in the EU may impose restrictions on Fast/Priority.
• Cache configuration can be migrated to prompt_cache_options.ttl.

2.3. Codex: experimental context management

For long sessions, Codex can use context management mechanisms that go beyond simple history compression.

The idea is to retain important information such as:

• hypotheses investigated;
• hypotheses discarded;
• files inspected;
• tests executed;
• results obtained;
• decisions made.

A conceptual configuration can be:

The experimental context management configuration should be treated as such and verified against the current version of Codex before being adopted as a team standard.

Why does it matter?

In a debugging session lasting several hours, losing context can force the agent to re-investigate:

• which hypotheses were already discarded;
• which files were already reviewed;
• which commands already worked;
• which tests were already executed.

Note-taking reduces that repetition.

Important:

never store confidential information, secrets, API keys, or sensitive data in persistent agent notes.

2.4. Approvals and sandbox

The goal of automation should not be:

"That the agent can do absolutely everything."

The goal should be:

Automate everything that is reversible and maintain human intervention only at irreversible or high-risk points.

Recommended interactive configuration as a starting point:

The agent can take care of:

• reading files;
• running tests;
• analyzing logs;
• making local changes;
• creating commits;
• preparing a Pull Request;
• reviewing its own work;
• correcting errors.

The human must maintain control over:

• production;
• deployments;
• final merge;
• publishing;
• sending external information;
• modifying permissions;
• irreversible operations;
• confidential information.

Approval should become the last checkpoint, not a constant interruption throughout the process.

2.5. AGENTS.md and Skills

Before starting an important job with Codex, the agent must know the project rules.

A useful architecture is:

AGENTS.md

Contains:

• permanent rules;
• allowed scope;
• restrictions;
• completion conditions;
• mandatory tests;
• human approval points.

Skills

Contain:

• repetitive procedures;
• workflows;
• operational checklists;
• specialized processes.

MCP

Used for:

• external connections;
• services;
• tools;
• data sources.

A simple division would be:

AGENTS.md = rules

Skills = procedures

MCP = connections

Minimum example of AGENTS.md

3. How to write instructions that leverage Astra

The quality of instructions has a huge impact on long-running agents.

Astra can be very sensitive to:

• ambiguities;
• contradictions;
• obsolete instructions;
• inconsistent Skills;
• duplicate rules.

Therefore, a good configuration can improve performance as much as changing models.

3.1. Increase autonomy

Instead of creating instructions that make the agent constantly ask for confirmation, clearly define the space within which it can act on its own.

3.2. Approval after reviewable results

One of the best rules for autonomous agents is:

First produce a reviewable result; then ask for approval for the irreversible step.

This avoids the pattern:

agent → question → human → agent → question → human

and replaces it with:

agent → investigates → implements → tests → prepares result → human approves → final action

3.3. Questions that do not block the main task

In long sessions it can be useful to allow independent questions without stopping the main flow.

A good rule is:

The main task has a fixed one-sentence completion condition. If an independent question appears during execution, answer it briefly without interrupting the main task. Only stop the main workflow when the question changes the task direction, scope, permissions, or required output.

The API can also use mechanisms to send additional instructions during an execution and asynchronous tools for prolonged work.

3.4. Delegation to subagents

When a task can be parallelized, do so explicitly.

If parallelization is likely to reduce execution time or improve quality, delegate independent subtasks to other agents. Prefer parallel work for independent investigations, module-level changes, test verification, documentation checks, and code review. Keep inter-agent messages concise, explicit, and readable.

Examples of parallelization:

• Agent A → investigate authentication module.
• Agent B → analyze tests.
• Agent C → review types.
• Agent D → review documentation.

Then, the main agent integrates the results.

3.5. Control test volume

More tests do not always mean a better result.

For small changes:

The goal is to prevent a trivial modification from triggering a huge battery of unnecessary tests.

3.6. Template for prolonged debugging

3.7. Template for computer and browser tasks

4. Maximize value, not token count

The right question is not:

"How can I spend all of Astra's tokens?"

The right question is:

"How can I get more work completed for every dollar spent?"

According to the indicated rates:

Astra is clearly more expensive per token.

But the price per token does not necessarily represent the actual cost of completing a task.

If Astra achieves:

• fewer errors;
• fewer iterations;
• less rework;
• fewer tool calls;
• lower total time;
• higher success rate;

then the cost per completed task can be competitive or even lower.

4.1. Practical routing table

The general rule:

Luna/Terra for volume → Sol for standard work → Astra for jobs that truly justify their cost.

4.2. Habits that reduce costs

1. Write the completion condition first

This reduces unnecessary exploration.

1. Avoid intermediate monologues

Prioritize:

State → Next action → Result

instead of endless explanations.

1. Send simple verifications to economical models

Don't waste Astra on:

• checking format;
• summarizing small logs;
• classifying files;
• performing repetitive tasks.

1. Stabilize the instruction prefix

Keeping system/developer instructions consistent can favor efficient cache usage.

1. Use fast modes only when they add value

If a mode costs more, it must be justified by a real reduction in execution time.

4.3. Weekly cost audit

Each week review:

• tasks executed with Astra;
• reason why it was used;
• result;
• approximate cost;
• if Sol would have been enough;
• if Terra would have been enough;
• number of iterations;
• failures;
• rework.

Simple rule

If you cannot explain in writing:

"Astra was necessary because..."

consider moving that category of tasks to a lower model.

5. Recommended Workflow

5.1. Long debugging

Step 1 — Classification

If there are multiple files, complex reproduction, or many tools:

Astra.

If it's simple:

Sol/Terra.

Step 2 — Limits

Define in AGENTS.md:

• allowed files;
• prohibited files;
• allowed commands;
• mandatory tests;
• approval points.

Step 3 — Configuration

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

Step 4 — Start

Always start with a clear completion condition.

Step 5 — Log

Retain:

• hypotheses;
• tests;
• results;
• files examined;
• decisions.

Step 6 — Interruptions

Independent questions must not destroy the context of the main task.

Step 7 — Deliverable

The agent can go as far as:

Pull Request ready for review.

The final merge remains under human control.

Step 8 — Learning

If the same problem appears repeatedly:

turn it into a

Skill

.

5.2. Large-scale refactoring

A two-stage strategy works well:

Stage 1 — Cheap investigation

Use:

Luna → Terra → Sol

to build:

• dependency map;
• impact;
• affected modules;
• risks;
• execution plan.

Stage 2 — Implementation

Use:

Astra

for the modules that truly require higher capacity.

Stage 3 — Parallelization

Subagents for:

• tests;
• type checking;
• review;
• independent modules.

Stage 4 — Human review

The human concentrates on:

• architecture;
• public APIs;
• compatibility;
• irreversible decisions.

5.3. Computer use

For browser or GUI tasks:

1. Clearly define the target screen.
2. Define prohibited operations.
3. Use Astra when the task is long or visually complex.
4. Use the latest Codex harness when applicable.
5. Log states and procedures.
6. Turn the result into a reviewable deliverable.

The 1.9× figure in Mind2Web should be interpreted only as a benchmark, not as a guarantee of internal performance.

5.4. API-based agent

Conceptual configuration:

Model: gpt-6-astra API: Responses Reasoning: low → high when required Tools: enabled Long-running tools: asynchronous when appropriate Human gate: final irreversible action

For long-running tools:

Use asynchronous tool execution when the tool runtime is long enough that blocking synchronous execution would reduce throughput.

If the difficulty level changes during execution:

Increase reasoning effort only when the task becomes genuinely difficult. Return to a lower reasoning level for routine execution when appropriate.

The idea is to reserve the most expensive resources for the moments that truly need them.

6. Dos and Don'ts

Do

• Reserve Astra for tasks where it makes a real difference.
• Review inconsistencies between AGENTS.md and Skills.
• Keep approvals as the last checkpoint.
• Generate reviewable results before requesting authorization.
• Activate context management for long tasks when applicable.
• Log hypotheses, tests, and results.
• Treat benchmarks as guidance, not an internal KPI.
• Measure success rate and time per task.
• Check from the beginning if a task requires Daybreak.
• Keep confidential information out of persistent notes.

Don't

• Use Astra for every small question.
• Interpret promotional phrases as technical specifications.
• Treat individual X or Reddit experiences as official documentation.
• Declare enterprise deployment before the administrator enables it.
• Give automatic access to irreversible operations.
• Store secrets or confidential information in context files.
• Run huge test batteries for trivial changes.
• Use external benchmarks as a substitute for internal metrics.

7. 60-Minute Implementation Plan

0–5 minutes

Check if gpt-6-astra is available:

• model selector;
• API;
• Codex.

If it is Enterprise, verify administrator permissions.

5–15 minutes

Check:

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write"

And, for context experiments:

[features.context_management] experimental_mode = true

Restart Codex if necessary.

15–25 minutes

Update AGENTS.md:

• scope;
• restrictions;
• tests;
• completion conditions;
• approval points.

25–35 minutes

Create a routing table:

Luna → Terra → Sol → Astra

35–55 minutes

Execute a real debugging task of limited scope with Astra.

Use an explicit completion condition.

55–60 minutes

Log:

• Was Astra really necessary?
• Would Sol have been enough?
• How much rework did it prevent?
• What configuration worked?
• What should become a Skill?

That's enough.

You don't need to test every available feature.

Distribution + limits + long sessions = the foundation for leveraging Astra.

8. Recurrent Practical Patterns

1. Two-stage rocket

Economic model → Astra

First:

• investigation;
• scope definition;
• analysis.

Then:

• complex implementation;
• integration;
• verification.

2. Completion condition from the start

In long agents, write in the first part of the instruction:

"The task will be finished when..."

This prevents aimless exploration.

3. Context and note-taking

For long jobs, retain:

• hypotheses;
• results;
• decisions;
• tests;
• important files.

Do not rely exclusively on the agent's compressed memory.

4. Approval must be the last step

Do not interrupt constantly.

Better:

Investigate → implement → test → prepare result → review → approve → execute irreversible action

5. Benchmarks as guidance

Mind2Web and OSWorld can help you decide what to test.

But the real KPIs must be internal:

• success rate;
• execution time;
• cost per task;
• number of iterations;
• rework;
• human intervention.

9. Common Errors

Before concluding:

"Astra is weak."

check first, in this order:

1. Visibility

Is the model actually available?

1. Framework

Is Codex updated and correctly configured?

1. Prompt

Are the instructions clear?

1. AGENTS.md

Are there contradictory rules?

1. Skills

Are there old or inconsistent procedures?

1. Routing

Are you using the right model for the job?

Often the problem is not the model's capacity.

It is the environment in which the model is working.

10. Implementation Checklist for Teams

• Define who will use Astra.
• Activate necessary administrative permissions.
• Establish an owner and a deadline.
• Create a Luna/Terra/Sol/Astra routing table.
• Create a minimal AGENTS.md.
• Define approval_policy.
• Define sandbox_mode.
• Define human intervention points.
• Document confidential operations.
• Establish a weekly cost review.
• Log which tasks actually require Astra.
• Convert repetitive errors into Skills.

The priority should be to reduce team errors and rework, not simply to maximize the speed of an individual agent.

11. Decision Tree: Sol vs. Astra

Use this sequence at the start of a task:

1. Can it be completed in a single exchange?

Yes → Luna / Terra / Sol

No → continue.

1. Does it need a GUI, tools, or many steps?

Yes → Astra

No → continue.

1. Is the cost of failure high?

Yes → Astra

No → Sol/Terra

1. Can the task change in difficulty during execution?

Yes → consider Astra + dynamic reasoning adjustment.

1. Is Astra still unavailable?

Execute the same workflow with Sol.

When Astra appears, change only the model and keep the structure.

12. API Migration to Astra

The recommended order is:

1. Change the model

model = "gpt-6-astra"

1. Use Responses API

Especially if there are tool calls.

1. Review reasoning

Astra does not use:

reasoning.effort = "none"

Start with a low level when sufficient.

1. Remove unnecessary parameters

Review parameters like:

temperature top_p

if the model or endpoint no longer supports them.

1. Review cache

Migrate to:

prompt_cache_options.ttl

when applicable.

1. Review data residency

If you use infrastructure or residency requirements in the EU, verify the corresponding restrictions.

1. Adjust reasoning dynamically

During a difficult task:

Increase reasoning effort when the task becomes genuinely difficult.

During routine operations:

Return to a lower reasoning level when additional reasoning is no longer useful.

1. Long tools

Consider asynchronous execution when tool time justifies it.

13. Minimum Codex Configuration

An initial configuration can be:

model = "gpt-6-astra" model_reasoning_effort = "high" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

And the repository should contain an AGENTS.md that defines:

AGENTS.md ## Goal - Keep changes minimal. - Completion requires all required tests to pass. ## Allowed scope - src/ - tests/ ## Approval gates - Production deployment - External data transmission - Permission changes - Final merge ## Operating behavior - Work autonomously within the approved scope. - Prefer reversible actions. - Produce reviewable results before requesting approval. - Do not ask unnecessary confirmation questions.

After modifying the configuration:

1. restart Codex;
2. execute a small reading task;
3. verify that the environment works;
4. start the main task.

14. Define "maximum utilization" in a single sentence

In this document, maximum utilization does not mean consuming the maximum number of tokens.

It means:

Concentrating Astra on tasks where it can truly make a difference, executing everything else economically, and building a solid foundation of instructions, limits, approvals, and context management that allows long tasks to be completed without unnecessary interruptions.

Several decisions follow from this definition:

• It is better to update the routing table weekly than to change models arbitrarily.
• It is better to perform a real debugging test than to try every new feature.
• It is better to measure success and time per task than to chase benchmarks.
• We must not turn promotional phrases into internal specifications.
• If Astra is unavailable, Sol can be used as a temporary substitute.

15. The Three Fundamental Deliverables

In the end, this entire system should produce three elements:

1. Dynamic allocation table

Defines when to use:

Luna / Terra / Sol / Astra

2. AGENTS.md

Defines:

• rules;
• scope;
• restrictions;
• tests;
• completion conditions;
• human checkpoints.

3. Long operational prompt

Must define:

• role;
• objective;
• completion conditions;
• procedure;
• limits;
• tools;
• validation;
• output format.

These three elements are more important than memorizing the entire feature catalog.

16. Classification Card to Copy

Use this card at the start of each important session:

The card does not need to be perfect.

Its goal is to create a classification habit.

If you recommend Astra but the task only needs short answers, you are probably oversizing the model.

If Sol fails repeatedly due to loss of context or inability to complete a long chain of actions, it is probably time to move up to Astra.

17. How to Really Think About Price

Rates per million tokens are only part of the equation.

For example:

Astra

• Input: $10
• Output: $50

Sol

• Input: $4
• Output: $20

Astra costs more.

But let's imagine:

Sol

$5 of tokens + 4 attempts + 2 failures + human rework = high actual cost

Astra

$12 of tokens + 1 attempt + correct result = lower total cost per task

Therefore, for short tasks:

Price per token matters a lot.

For long tasks:

Cost per completed task matters much more.

The final metric should be:

Cost × success rate × time × human intervention

and not just:

$/1M tokens

Conclusion

The goal of Astra should not be to make it the default model for everything.

The goal should be to build a system where each model does the work for which it is most efficient.

Luna

Volume and simple tasks.

Terra

Balance between cost and capacity.

Sol

Standard work and general programming.

Astra

Complex, long, agentic, GUI, math, debugging tasks, and jobs where failure is expensive.

The most powerful pattern is:

Investigate cheap → plan → execute with Astra when necessary → verify → prepare a reviewable result → human intervention only at the final checkpoint.

True optimization is not about using Astra more.

It's about knowing exactly when Astra is worth it.

And the more complex the agents, the more important the infrastructure surrounding them: AGENTS.md, Skills, sandbox, approvals, context management.**