GPT-6 Astra needs less prompting than you think.

If you built your agent harness around GPT-4 or even GPT-5, your skills files are probably too long. OpenAI published developer guidance for GPT-6 Astra in September 2026, and the core message is blunt: stop over-prompting. The model handles ambiguity on its own now.

This matters if you maintain AGENTS.md, skill definitions, or structured task prompts. The patterns that made older models reliable make Astra slower. Here is what changed, and what to do about it.

What OpenAI actually said

The guidance covers three areas: skill descriptions, approval workflows, and task prompt structure. Each one points in the same direction. Less instruction, more trust.

Skill descriptions are eating your context

Skills in agent frameworks are Markdown files that describe what an agent can do, what resources it has access to, and how to use them. Claude Code, Codex, Hermes Agent, and a dozen others all use some version of this pattern.

The problem: when you have 15 skills loaded and each one runs 200-400 words, you are burning 3,000-6,000 tokens on instruction before the model sees the actual task. Astra's context window is large, but context is not free. Every token spent on skill metadata is a token not spent on the problem.

OpenAI's recommendation is to cut skill descriptions to the minimum the model needs. If a skill is "deploy to production," you do not need a paragraph explaining what production means. The model knows. What it needs is the specific constraint: which server, which path, what to do on failure.

Too many approval gates slow everything down

Agent frameworks added approval workflows as a safety measure. Before the model writes a file, confirm. Before it runs a command, confirm. Before it makes an API call, confirm.

With GPT-4, these gates were necessary. The model would sometimes take actions that made no sense in context. With Astra, the failure modes are different. The model is more likely to do the right thing, and the approval gates now mostly serve as speed bumps that interrupt useful work.

OpenAI's guidance: keep approvals for genuinely destructive actions (deleting data, spending money, sending external messages). Remove them for file edits, local commands, and read operations. The model can be trusted with those.

Step-by-step sequences can hurt

This is the counterintuitive one. Detailed step-by-step instructions in task prompts can actually slow Astra down. The model has enough reasoning capability to plan its own sequence. When you provide a rigid 10-step plan, you are overriding its judgment with yours, and yours is based on less information than the model has at execution time.

The guidance says: describe the outcome, list the constraints, let the model figure out the path. If you need specific steps (because the environment has quirks the model cannot know), include them. But do not spell out what the model can infer.

What this means for your harness

If you are running an agent framework with skills, here is a concrete before-and-after.

Skill description: before and after

Before (GPT-4 era):

## deploy-production

This skill handles deploying code to the production environment.
Production is the live server that real users access. You should be
very careful when deploying to production because mistakes can affect
real users. Before deploying, always:

1. Run the test suite and confirm all tests pass
2. Build the production bundle
3. Check that the staging environment looks correct
4. Create a deployment commit
5. Push to the main branch
6. Monitor the deployment logs for errors
7. Verify the site is accessible after deployment
8. If anything fails, roll back immediately

Resources: production server at 10.0.1.5, deploy key at ~/.ssh/deploy

After (Astra):

## deploy-production

Deploy current branch to 10.0.1.5. Run tests first. Roll back on failure.
Deploy key: ~/.ssh/deploy

Same information. One-sixth the tokens. The model knows what production is, knows to run tests first, and knows to roll back on failure. The only things it cannot guess are the specific server address and key location.

Approval workflow: before and after

Before:

approval_rules:
  - action: file_write
    require_approval: true
  - action: file_read
    require_approval: true
  - action: shell_command
    require_approval: true
  - action: api_call
    require_approval: true
  - action: git_push
    require_approval: true

After:

approval_rules:
  - action: shell_command
    pattern: "rm *|DROP *|DELETE *"
    require_approval: true
  - action: api_call
    external: true
    require_approval: true
  - action: git_push
    branch: "main"
    require_approval: true

Three targeted rules instead of five blanket ones. File reads and writes happen without friction. Shell commands are gated only when they match destructive patterns. API calls to external services still need approval. Git pushes to main still need approval. Everything else flows.

Why this happened

The shift is not mysterious. GPT-6 Astra was trained with more sophisticated reinforcement learning from human feedback, longer reasoning chains during training, and better calibration. It is better at knowing what it knows.

Older models needed explicit guardrails because they would confidently do the wrong thing. Astra is more likely to pause, ask for clarification, or take a conservative approach when it is uncertain. The guardrails you built for GPT-4 are now redundant in many cases, and the overhead they add is measurable.

There is a parallel with how developers adjusted to Claude Fable 5, which shipped with thinking always on. The models that reason internally need less external scaffolding. The models that cannot reason need every instruction spelled out. We are in the transition period where most harnesses are still built for the second category.

Migration checklist

If you want to tighten your harness for Astra, here is the sequence:

1. Audit your skills. Count the total tokens across all skill files. If you are over 2,000 tokens, cut the descriptions. Keep resource identifiers, constraints, and failure handling. Remove anything the model can infer.
2. Review your approval rules. List every gated action. For each one, ask: "What is the worst case if the model does this without asking?" If the answer is "it writes a file I can git revert," remove the gate.
3. Test task prompts without step-by-step instructions. Take your five most common tasks. Rewrite the prompts to describe the outcome and constraints only. Run each one three times. If the model succeeds all three times, keep the shorter prompt.
4. Check your AGENTS.md. OpenAI specifically recommends reviewing this file when switching models. If it was written for GPT-4, it probably contains instructions Astra does not need.
5. Monitor, do not pre-empt. Instead of blocking actions before they happen, log them and review. You will catch the same problems with less friction.

The trade-off

This is not risk-free. Removing guardrails means trusting the model more. If Astra makes a mistake, it will happen faster and without a checkpoint to catch it.

The counter-argument is that the old guardrails were not actually preventing mistakes. They were preventing speed. A model that needs to pause for approval on every file write is a model that loses context between actions. The approval step interrupts the reasoning chain, and the model has to reconstruct its plan after each gate.

OpenAI's position is that the net risk is lower with fewer gates, because the model maintains better situational awareness when it is not constantly stopped. Whether you agree depends on your use case. If your agent is editing production databases, keep the gates. If it is writing code in a sandbox, let it run.

What to watch next

The broader trend is clear. As models improve, the scaffolding around them should shrink. Every piece of instruction you add to a harness is a bet that the model cannot figure something out on its own. That bet was safe 12 months ago. It is less safe now.

If you are building a harness today, build it for the model you will have in six months, not the model you have now. The skills files you write today will still be loaded when Astra's successor ships. Make sure they are not carrying dead weight.