“Start Astra in an empty folder. Throw away all your old skills. Reach the answer in one shot. If you need a correction, restart from nothing.”
That exaggerated summary is memorable because it sounds plausible. Anyone who has piled rules onto an AI agent can imagine the machine spending half the day reading the employee handbook before touching the task.
But OpenAI’s actual guidance is more precise.
Do not delete everything. Load only what matters, when it matters.
And this is not just a Skills or AGENTS.md issue. The same logic applies to long chats and long-running Codex sessions.
As a session grows, old messages, tool outputs, logs, abandoned attempts, and superseded instructions can remain available as material for the next decision. Useful history is powerful. Irrelevant history is like working at a desk covered with last year’s receipts, broken USB sticks, and six versions of the same checklist.
This article separates the meme from the official guidance, explains what actually grows in a long session, what caching does and does not solve, and why “read the previous session and continue” only helps when the handoff is compressed.
1. OpenAI is not saying “go empty”; it is saying “audit old scaffolding”
On September 11, 2026, OpenAI Developers published “Rethinking skills and prompts for GPT-6 Astra.”
The target is the large amount of guidance teams accumulated to compensate for older models. A previous model might skip documentation, forget tests, or act too aggressively, so people added rules such as “always read these three documents,” “run the entire test suite every time,” or “always ask for approval first.”
Astra follows instructions more strongly. The official model guide warns that it is more sensitive to instructions in Skills, AGENTS.md, and other context, and that unclear or conflicting guidance can make it pause or block work too early.
So the problem is not that Astra ignores rules.
The problem is that it may obey obsolete helper rules very faithfully.
OpenAI even uses unconditional pre-reading of a stack of docs as an example of wasted context and slower work.
The Astra-era pattern is therefore:
- Keep Skill descriptions short and specific about when they apply.
- Keep always-on rules in
AGENTS.mdgenuinely always-on. - Load task-specific documentation only for the relevant task.
- Define what “done” means before starting.
- Re-audit old approval, stopping, and testing rules added for weaker models.
Think small constitution plus on-demand manuals, not one enormous constitution for every possible job.
2. How true are the four viral claims?
“Start in an empty folder” is an overstatement. OpenAI does not tell you to discard an existing repository or all prior context. It says to read what the task needs.
“Delete every old Skill” is also wrong. The recommendation is to narrow triggers, shorten descriptions, and remove contradictions and unnecessary constraints.
“Reach the answer in one shot” is only partly related. OpenAI stresses defining completion so Astra does not stop after a first implementation when the task actually includes running, inspecting, and fixing the result. That is not the same as demanding a perfect one-shot answer.
“If a correction is needed, restart from zero” points in the opposite direction from a major Astra feature. Mid-turn steering lets new requirements or corrections arrive during work while completed work is preserved.
The better summary is therefore:
Do not become amnesiac. Stop keeping useless memories permanently active.
3. Does context usage really grow as a session continues?
At the API level, generally yes.
A model does not necessarily see only the newest sentence. Prior messages, tool results, instructions, and conversation state that are preserved or replayed become input context for the next response.
A simplified early turn might look like this:
5k previous tokens + 1k new tokens = about 6k input
A much later turn could look like this:
100k previous tokens + 1k new tokens = about 101k input
Actual systems may compact, truncate, cache, or selectively retain state, so the exact number varies. But long history is not an infinite free attachment.
OpenAI’s Realtime API documentation makes the mechanism explicit: as a conversation grows, earlier outputs become input for later responses.
4. Does prompt caching make context bloat harmless?
Caching helps a lot. It is not a magical trash compactor.
As of September 14, 2026, GPT-6 Astra API pricing lists $10 per million normal input tokens, $1 per million cached input tokens, and $50 per million output tokens. Prompts above 272k input tokens are priced at 2x input and cache rates and 1.5x output for the full request.
A stable cached prefix can therefore be much cheaper to reuse. But:
- Newly added context keeps growing.
- A cache miss returns those tokens to normal input pricing.
- Huge context can still contain irrelevant or conflicting instructions.
- Crossing a size threshold can change the pricing regime.
So “it is cached” does not mean “dump everything into context forever.”
Also, API pricing is not the same thing as a ChatGPT, Codex, or Work product quota. Public information does not justify the stronger claim that a long ChatGPT thread depletes a user’s product allowance in a perfectly linear ratio to historical tokens.
5. The bigger danger is not money; it is old rules turning into ghosts
Cost is only half of the problem.
Because Astra is instruction-sensitive, an old “always stop here,” an obsolete contract, or a defensive “run every test every time” rule can remain part of the material it considers.
Three kinds of clutter are especially dangerous:
Resolved clutter: fixed bugs, closed debates, rejected options.
Duplicate clutter: the same rule repeated in several wordings.
Superseded clutter: instructions that were once correct but no longer match the current branch, contract, or workflow.
A human says, “that was old.” A model sees context that still exists.
With a stronger model, the failure can paradoxically become: it follows unnecessary instructions better.
6. Is “read the whole previous session and continue” a good reset strategy?
Only halfway.
If you open a fresh session, paste or reload the entire previous session, and then keep all of it active again, you changed rooms but moved every box onto the new desk.
A better design treats the old session as a warehouse and the new session as a workbench.
Carry forward:
- Current state.
- Decisions already settled.
- Rules that are still valid.
- Unfinished tasks.
- Evidence, files, commits, or URLs needed for verification.
- Constraints that would be dangerous to lose.
Usually leave behind resolved discussion, giant trial-and-error logs, rejected approaches, duplicates, and obsolete rules.
Carry forward only what matters.
7. A practical handoff prompt
A compact handoff can be as simple as:
Review the previous session and continue by carrying forward only the current state, settled decisions, active rules, unfinished tasks, and evidence needed to verify the work.
Do not reproduce or preserve the old log verbatim. Drop obsolete instructions, resolved discussions, intermediate history, and duplicate information. Keep only the context required for the current task.
Do not redo work already completed in the previous session. Continue from the first unfinished point.
The key is not “never read the previous session.”
The key is: read it to extract current state, not to grant the entire history permanent residency.
Opening the warehouse once is fine. Putting every box on your desk is not.
8. When should you cut over to a new session?
Do not reset mechanically after a fixed number of turns. Reset or compact when you see signs such as:
- The same explanation keeps being reconstructed.
- The model revives rules that were already retired.
- Nobody can tell what is finished anymore.
- Tool logs are longer than the useful task state.
- The workflow has clearly moved into a new phase.
- The current state fits in 10–30 lines while the history spans thousands.
Long workflows such as research → implementation → verification → release are especially easy to compact at phase boundaries.
For API workflows, OpenAI also provides compaction for long-running, tool-heavy work so prior state can be compressed while retaining task-relevant information.
9. Conclusion: empty is not the goal; a clean workbench is
Astra does not need amnesia.
Keep real knowledge, settled decisions, and important boundaries. What you should stop doing is forcing every historical detour to remain active as if it were a current instruction.
Older agents had a “do not forget” problem.
Astra adds another problem: how do we clean up the mountain of instructions we taught earlier agents to remember?
The useful mental model is:
Old session = warehouse.
New session = clean workbench.
Handoff = shipping manifest containing only the boxes still needed.
You do not need a cult of the empty folder. You just need to remove last year’s receipts and the broken USB stick from the desk.
Sources
- OpenAI Developers, “Rethinking skills and prompts for GPT-6 Astra,” Sep. 11, 2026. https://developers.openai.com/blog/rethinking-skills-and-prompts-for-gpt-6-astra
- OpenAI Developers, “Model guidance — Using GPT-6 Astra.” https://developers.openai.com/api/docs/guides/latest-model
- OpenAI API Reference, Realtime server events / token usage and conversation context. https://platform.openai.com/docs/api-reference/realtime-server-events
- OpenAI Developers, “GPT-6 Astra Model.” https://developers.openai.com/api/docs/models/gpt-6-astra
- OpenAI Developers, “Compaction / conversation state guidance.” https://developers.openai.com/api/docs/guides/compaction
