GPT-6 Astra: Reproducible Telemetry on Quota Consumption from 30-Second Subagent Polling

One-sentence conclusion

In a single Astra parent-agent orchestration, 47 30-second polls with no state change processed 7.13 million input tokens, accounting for approximately 68% of the parent agent’s input volume and showing that short-interval polling can amplify the context cost of a high-priced parent model.

Applicable scenarios

• Suitable tasks: Codex multi-agent orchestration, long-running Luna workers, investigating abnormal quota consumption, and designing wait_agent intervals and cache tradeoffs.

• Unsuitable tasks: Inferring a quota multiplier for all Astra tasks from this result, or directly converting a subscription usage percentage into API dollar costs.

• Applicable model versions: GPT-6 Astra as the parent agent; GPT-5.6 Luna XHigh as the workers; GPT-5.6 Luna Max as the comparison session.

• Applicable clients, Agents, or APIs: Codex with rollout telemetry and subagent collaboration tools.

• Recommended reasoning tier and parameters: The article does not disclose Astra’s effort setting; the author suggests an experimental wait interval of approximately 20–25 minutes, below their assumed cache TTL of approximately 30 minutes. This recommendation was still being tested when the post was published and must not be treated as a validated conclusion.

Test environment, inputs, and configuration

• An Astra orchestration session and an earlier Luna Max comparison session on the same Plus account.

• The Astra parent agent waited for Luna workers and observed 47 consecutive 30-second timeout polls; none of the 47 returned a new worker state.

• Two Luna XHigh workers executed the actual task. The first worker was interrupted twice by the parent agent; after the second interruption, the author found that it had already produced 2 file modifications, 127 lines added, and 6 lines deleted. A replacement worker then continued the work.

• The comparison group was a real 127-minute work session in which all 12/12 turns used Luna Max context.

• The article provides a telemetry summary but does not disclose the complete rollout files, original task prompt, parent-agent effort, repository contents, or account-limit algorithm.

Raw data

• Each empty poll processed approximately 151.7K input tokens on average.

• 7.13M / 10.46M ≈ 68%, meaning that approximately 68% of the parent agent’s raw input volume came from timeout polls with no new state.

• The two Luna XHigh workers used approximately 2.05 times the input volume of the Luna Max comparison.

• The author used a linear-scaling upper-bound estimate: 8 × (19.514M / 9.538M) ≈ 16.4 percentage points. Even accepting that simplification, it still cannot explain the observed +47 percentage points; however, because the subscription quota algorithm is undisclosed, this is not a strict cost attribution.

Conclusions and applicable boundaries

The strongest evidence is that the polling count, per-poll context size, and parent-agent token summary cross-check one another; together, they support the claim that “short polling causes substantial repeated context processing.” The extremely high share of cached input indicates that extending the wait interval also requires considering cache-expiration risk. Commenters noted that longer waits could turn the context into uncached input; the author proposed 20–25 minutes only as a tradeoff that still needs validation.

These data cannot prove that the entire +47 percentage-point increase was caused by the Astra parent agent, because the workers, account-limit weighting, Fast/Standard status, and server-side metering formula were not fully disclosed. Nor can the Luna Max per-token quota change be linearly extrapolated to Luna XHigh; the 16.4 figure in the article is only a sensitivity estimate.

Reproduction steps

1. On the same account and client version, fix the parent/child models, effort, task, repository, context, concurrency, and service mode.

2. Save complete rollout telemetry and record, for each wait_agent call, its start time, timeout, returned state, input/cached/output/reasoning tokens, and the number of parent-agent re-entries.

3. Run at least three groups: 30-second polling, 20–25-minute waits, and event-driven wakeups; keep the worker task and runtime consistent.

4. Report the parent agent and each worker separately, including tokens, usage percentage, wall-clock time, completion level, interruption/replacement count, and cache hits.

5. Repeat multiple times and record the client version to distinguish model behavior, harness bugs, cache strategy, and temporary server-side metering changes.