When GPT-6 Astra Continues Without Clarifying, Preserve the Assumption

When GPT-6 Astra fills a routine gap and keeps working, the thing that must remain reviewable is not just the final answer. The reviewable unit is the assumption, the decision it affected, and the artifact that decision changed. That is the smallest bundle later steering can safely revisit without guessing which part of the task was actually changed.

Use a caller-owned assumption record with four fields: assumption, impacted decision, evidence, and recompute rule. Keep it in the same task state that you resend when continuing the model request. OpenAI’s Astra guidance says the model fills routine gaps from context and asks focused questions when the answer could change the outcome. OpenAI’s steering guidance also says mid-turn instructions can preserve completed work in a continuation. On the CometAPI side, the GPT-6 Astra guide says tool calling requires the Responses API, and changing reasoning effort mid-conversation uses configuration_update items. Together, those facts support a simple interface rule: carry the assumption record forward with the request, not in a separate note that the continuation cannot see.

Assumption/impact/evidence/recompute table:

Assumption Impacted decision Evidence to keep Recompute rule
The gap is routine, not boundary-changing Continue without a clarifying turn The exact prompt, model choice, and the assumption row If the answer could alter scope, safety, or authorization, stop and ask a focused question
The model should continue with preserved context Resume the same task in the next request The prior assistant state plus the assumption row If the continuation loses the assumption row, re-send it before proceeding
The right interface is Responses API for tool-heavy work Route the continuation through the same request family The model ID, tool settings, and continuation payload If a different interface is used, re-check that it supports the same steering behavior
A reasoning change is intentional, not accidental drift Update effort or steer mid-conversation The configuration_update item and its timestamp If the effort change is missing, keep the previous effective effort

Illustrative test design: start with a task that needs one routine gap filled, then inject a mid-turn correction that changes the requested artifact. The expected result is that the original assumption row is still visible, the impacted decision is rewritten, and the artifact is regenerated from that updated record. That test is illustrative only; no live CometAPI request or billing trial has been performed here.

Correction example: suppose the task initially assumes “a draft note is enough” and continues to a summary. Later steering shows the real need is an assumption/impact/evidence/recompute table. The correction should not leave the old summary as the current answer. Instead, replace the assumption row, update the impacted decision from “write summary” to “produce table plus correction example,” and recompute the artifact from the caller-owned state. That preserves auditability because later reviewers can see both what was assumed and what changed.

This matters for safety governance because routine gap-filling is useful only while the model’s private inference stays reviewable. Once a gap affects a boundary decision, the reviewable object must be the record of the assumption and its recompute path, not a vague memory of how the answer happened. That is the difference between a steerable workflow and an untraceable one.

One implementation detail I would add is a version and disposition to each assumption row. “Recompute if the assumption changes” is useful only if the caller can tell which artifact was produced from which row, and whether the old artifact is still eligible to be used.

For example, the caller-owned state could carry:

Field Example
assumption_id delivery-format-01
version 2
text “A Markdown table is acceptable as the handoff artifact.”
decision “Render a table, then continue the request.”
artifact_revision answer-2
status active
recompute_when “The consumer requires JSON instead.”

When a steering message changes the requirement, do not mutate answer-2 in place. Mark its row superseded, append version 3 with the new decision, and generate answer-3 from that row. The continuation should receive the active rows plus an explicit instruction to disregard superseded artifact revisions. That makes a resumed request deterministic for the caller even if the model retains earlier conversational context.

This also gives the tool boundary a concrete stop condition. A tool result or external side effect should record the assumption version it used. If the active version changes before that effect is committed, the application should pause for reconciliation rather than silently presenting the old result as current. The CometAPI guide’s Responses API and configuration_update details explain how to continue and change reasoning effort; they do not, by themselves, provide this application-level versioning. The table above is therefore a proposed design, not a claim about a built-in gateway feature. An illustrative test would steer from Markdown to JSON between two steps and verify that the final artifact is answer-3, while the superseded answer-2 remains available for review.