Sol Executes, Astra Advises

Table of contents

• How I used the first two limits
• The post on X that made sense
• Trying Sol as the executor
• What I found in the logs
• The instructions I use now

In my last post, I wrote that perhaps I would put GPT-6 Astra to work on the next version of my wake-word model. Three weeks later I am using Astra, although not in the way I expected. Sol now executes and Astra advises.

I came to this arrangement after burning through two usage limits on my home cluster, reading what other people were reporting, and then asking Codex to inspect its own session logs.

How I used the first two limits

The first Astra results shared by people with access were impressive. I wanted to see what it could do with a real project, so I gave it an ambitious cleanup job in Soyspray, my home Kubernetes cluster.

I started this cluster several years ago while I was learning Kubernetes, Ansible, Argo CD, and everything around them. It works, but I built it by adding whatever I needed next. There was not much refactoring. The repository now contains new parts, legacy parts, half-replaced parts, and debris that I always intended to remove later.

I gave Astra a long handover and asked it to continue that work. I also tried Extra High and Ultra reasoning. If I had the strongest model, I thought I might as well turn up the brain setting and give it room to work.

Then I went for a walk with a friend. Astra did real work while I was away: it inspected the cluster, changed code, ran tests, and checked the result. It also used my whole limit. I had a saved usage reset and the task was large, so I did not worry about it. I used the reset, started another iteration, and went out again.

After the second limit was gone, I came back to the computer. The work was useful, but I had expected more from two full limits, and this time I wanted to know where they went.

The post on X that made sense

As usual, I checked X. Most posts were deserved praise for Astra, but one person said he was moving back to GPT-5.6 Sol as his main executor. He was not a billionaire or a privileged reviewer and could not keep buying more access every day, so Astra would advise while Sol did the routine work.

I did not save that post, so this is a paraphrase. I do remember why it caught my attention: the author had also been burned by Astra's usage and had arrived at a practical advisor-and-executor split.

I have a guess about the spectacular early examples. Perhaps those people gave Astra tighter tasks, or perhaps some reviewers did not need to care about their personal limits. I cannot prove either explanation. What I could do was check my own sessions and try the suggested split on a comparable cluster task.

Trying Sol as the executor

I opened a fresh Codex CLI session with GPT-5.6 Sol at Medium reasoning. The task was Soyspray issue #309: move the existing Prometheus monitoring stack under native Argo CD ownership without losing metrics, storage, credentials, or access.

Sol handled the investigation, implementation, tests, Git history, and pull request. Astra was a read-only advisor for the architecture and safety decisions. This was still an ambitious job. The cluster did not have enough backup and restore evidence to make the live ownership change safely, so stopping in the correct place mattered as much as changing the files.

The session produced draft PR #310 with ten organized commits. The local and GitHub checks passed. Nothing was deployed, and the pull request records the backup, restore, and storage evidence required before deployment. That was the result I wanted.

What I found in the logs

First I asked Astra to analyze the earlier runs. Then I used Sol to trace the recent Astra sessions and the issue #309 session in which Astra acted as advisor. I compared the local Codex rollout logs with OpenAI's current credit rates. The figures below are credit-equivalent estimates, not an invoice from my account.

The mixed run used 10.2% fewer raw tokens and approximately 47.2% fewer credits. Astra handled 10.5% of its raw tokens but represented 31.5% of the estimated credits. That agrees with OpenAI's current pricing: Astra costs 2.5 times as many credits as Sol for uncached input, cached input, and output tokens.

The raw token totals look ridiculous until the cache is included. About 96.8% of the mixed run's input was cached. The agents did not write sixteen million tokens of new text. They carried a large project context through many model responses, and cached input was cheaper but still counted.

Sol produced about one hundred model responses during the issue #309 run. The Astra advisor added six logical turns and twenty-two model responses. Some of those turns only confirmed that nothing else needed to change. I was paying a more expensive model to confirm its own advice after the decision was already made.

OpenAI's subagent documentation says that each subagent does its own model and tool work, which adds tokens. It calls Medium a balanced default and recommends High for reviewers that must trace complex logic. OpenAI's Astra guidance also says that Astra tends to answer in detail and can run broader tests than a small task needs.

Other users were reporting the same usage issue in OpenAI's Codex repository. One said a fresh Astra limit went from 100% to zero in 20 minutes. Another reported that a reset lasted less than one hour. A third posted a same-day Astra-to-Sol comparison after the allowance fell fast enough to force a switch.

These reports do not prove that everybody hit one accounting bug, and my logs cannot prove what happened on OpenAI's servers. They do show a real usage issue. People got burned by it and talked about the advisor-and-executor approach on X. In my own sessions, I found one part that I could fix: I had an expensive model doing ordinary executor work in a long context.

The Astra-only session in this comparison was running at Medium, so Ultra was not the whole explanation. There could still be a billing, quota, or client bug. I want OpenAI to fix its shit, but I cannot honestly say which part is broken.

The instructions I use now

Sol is my default executor at Medium reasoning. It investigates, changes files, runs tests, and delivers the work. Astra stays at High reasoning as a read-only advisor for decisions where a second opinion is worth the price.

Before a consequential change, Sol sends Astra one compact packet with the objective, constraints, proposed solution, remaining questions, and relevant evidence. Before delivery, it sends the actual diff, test results, and important wording for one final review. If Astra approves, the review ends. Sol does not ask it to confirm the confirmation.

This keeps Astra involved where its judgement helps me, without paying Astra rates for every search, command, test, and explanation. If you want Codex to inspect your own runs, this is the prompt I would use:

Compare my latest Astra-heavy Codex session with the closest similar Sol
session. Read the local rollout JSONL logs. Separate uncached input, cached
input, and output tokens. Apply the current official Codex credit rates.

Show the number of model responses, the advisor's share, and the estimated
credits for each run. Separate measured facts from speculation.

Then propose the smallest AGENTS.md and agent TOML changes that keep Sol as
the executor and Astra as a read-only advisor. Do not edit anything until I
approve.

Times are changing very fast. I asked my home computer to analyze the sessions and went for a walk. While it worked at home, I continued the same conversation through Codex Remote on my phone and dictated this draft outside. Later I finished the edit in that conversation and asked GPT to publish it on this website.

I am keeping Astra. I like its advice on difficult decisions. I just stopped asking it to do all the manual work.