Build a GPT-6 Adoption Scorecard

Introduction

30 Second Summary

A polished AI recommendation can win confidence before anyone checks what it assumed. When the model or budget changes, those hidden guesses can steer a real project in the wrong direction.

In this project, you will build a browser-based GPT-6 Astra adoption lab using ChatGPT with official OpenAI Developer Documentation. Your lab turns a plausible but weak answer into a repeatable benchmark that powers an evidence-backed model scorecard.

What You'll Build

Your finished one-page scorecard gives a teammate a model recommendation for their workload with benchmark evidence, access caveats, and official sources in view.

By the end of this project, you'll have:

• A repeatable evaluation packet that lets you run three consistent prompts against any current or future model. You can score every answer out of 20 using direct evidence.
• A sourced four-model comparison that keeps positioning, access, supported capabilities, limitations, and standard prices visible for GPT-6 Astra, GPT-5.6 Sol, GPT-5.6 Terra, and GPT-5.6 Luna.
• A one-page recommendation scorecard that selects a model by workload. It also distinguishes the GPT-6 Astra API model from GPT-6 Pro in ChatGPT.
• Secret Mission: Add a requirement-change test that checks whether a model preserves earlier constraints when the budget and timeline change.

Are there any prerequisites?

Your existing ChatGPT account and internet connection are enough. This browser-only project requires no Python installation or OpenAI API account.

Before We Start

A specific future task gives your later model decision a clear purpose. Your one-sentence commitment names the task you may evaluate and why choosing an appropriate model matters.

Set Up Your Evaluation Workspace

Model claims are easy to misremember once comparisons begin. A clean workspace gives every later conclusion a visible source.

Your existing ChatGPT Free account keeps the project in one browser conversation. This setup requires no API account or paid API calls.

In this step, get ready to:

• Create a fresh ChatGPT conversation with its visible model or mode label recorded.
• Keep five official OpenAI references ready for source checking.
• Confirm that the retained conversation follows an exact response constraint.

Create a clean starting point

A fresh conversation separates this evaluation from your earlier chats. It becomes the retained record for your baseline and scorecard.

• Open ChatGPT in your browser using the account you already have.
• Sign in with your existing account if a sign-in screen appears.
• Use the conversation control in the left sidebar to start a fresh conversation.
• Check whether the conversation screen shows a model or mode label.
• Record the visible model or mode label exactly here: your displayed model or mode label.
• Enter Free account model label not displayed in the same field if no label is visible.

Your account state is now recorded without guessing which model or mode you can access.

Gather the canonical references

The OpenAI Developer Documentation provides the model evidence for your scorecard. The GPT-6 Astra pages cover the model-specific facts you inspect later.

• Open the OpenAI model catalog in a separate browser tab.
• Open the GPT-6 Astra model page in a separate browser tab.
• Open the GPT-6 Astra model guidance in a separate browser tab.
• Open the OpenAI API pricing page in a separate browser tab.
• Open the GPT-5.6 and GPT-6 Pro in ChatGPT help article in a separate browser tab.
• Leave all five reference tabs open for the rest of the project.

Your source trail is ready. Every later capability or price claim has an official page beside it.

Set a visible checkpoint

A narrow verification prompt tests whether the conversation follows a precise instruction. Its reply gives your evaluation workspace a clear starting line.

• Switch back to your fresh ChatGPT conversation.

Before you send it, do you expect ChatGPT to return only the requested sentence?

• Verify the workspace by sending this exact prompt:

Reply only with: GPT-6 evaluation workspace ready.

What Does This Check Prove?

• The exact wording gives the conversation one permitted reply.
• The clean response creates a visible checkpoint before the benchmark begins.

• Compare the response with the required sentence.

You should see GPT-6 evaluation workspace ready. with no extra text.

That exact reply confirms your retained conversation is ready for the evaluation work ahead.

Reply Includes Extra Text?

• Check that your prompt matches the code block exactly.
• Send the same prompt again in the retained fresh conversation.

Still seeing extra text? Help me check the verification prompt.

Your screenshot only needs to show the conversation text. Personal account details can stay outside the frame.

• Leave the verified conversation open for the rest of the project.

Your free evaluation workspace is verified with official sources ready beside it. Next, you will create the deliberately weak baseline that your scorecard needs to expose.

Create a Weak Baseline

Your ChatGPT evaluation workspace is ready. The retained conversation can now hold every evaluation artifact.

A polished answer can hide unsupported assumptions. In this step, you will capture that failure before adding any scoring method.

In this step, get ready to:

• Capture an unmodified launch plan from an intentionally vague prompt.
• Expose the important facts that the model supplied for itself.
• Mark at least three assumptions that block objective trust or reproduction.

Run the intentionally vague benchmark

A baseline preserves the model's first interpretation of a task. Keeping that first answer unchanged gives you an honest artifact to evaluate later.

Before you send the prompt, do you expect the plan to feel complete despite the missing context?

• Return to the retained ChatGPT conversation from earlier.
• Send the intentionally vague benchmark by pasting this prompt exactly:

You are advising a two-person team launching a study-planning app in 14 days with a $500 budget. Create the complete launch plan, choose every tool, assign daily work, define success, and recommend whether to launch.

What makes this prompt convincing?

• The prompt fixes a team size of two people.
• The prompt fixes a deadline of 14 days.
• The prompt fixes a budget of $500.
• The remaining choices force the model to fill in missing facts.

• Wait for ChatGPT to finish the complete launch plan.
• Keep the first response unchanged.

You should see a complete-looking launch plan that ends with a recommendation. This original response is your baseline artifact.

Baseline response incomplete?

• Keep the original baseline prompt unchanged.
• Request a continuation if the response stops before the launch recommendation.

Need help preserving the original response?

Expose the hidden assumptions

An assumption audit makes invisible choices visible. A useful audit pairs each missing fact with the recommendation it could change.

• Send the assumption audit by pasting this prompt exactly:

Audit your previous answer. List every important assumption you made because my prompt omitted necessary facts. For each assumption, explain how a different fact could change the recommendation.

What does this audit reveal?

• The first sentence asks ChatGPT to inspect its original launch plan.
• Each assumption must identify information missing from the baseline prompt.
• Each impact must explain how a different fact could alter the recommendation.

• Wait for ChatGPT to finish the complete assumption audit.

You should see a list of hidden decisions followed by the effect each one could have. The original plan now has an evidence gap you can point to.

• Mark the decision-blocking assumptions by sending this sentence exactly:

Mark at least three assumptions that prevent the original answer from being objectively trusted or reproduced.

Why mark the blockers?

• The marking step separates decision-blocking assumptions from minor details.
• Three marked blockers create a visible minimum for checking the audit.

• Wait for ChatGPT to identify at least three decision-blocking assumptions.

You should see at least three assumptions explicitly marked as barriers to objective trust or reproduction. Each one should retain an explanation of its possible effect.

Audit too vague?

• Check that each marked assumption names a fact missing from the baseline prompt.
• Check that each impact names a possible change to the launch plan or recommendation.

Need help identifying decision-blocking assumptions?

Before you inspect the full thread, do you think another evaluator could reproduce the first recommendation without the audit?

• Scroll to the baseline prompt in the retained ChatGPT conversation.
• Confirm that the complete original response appears immediately below the baseline prompt.
• Continue to the assumption-audit response.
• Count at least three explicitly marked assumptions.
• Check that every marked assumption explains how a different fact could change the recommendation.

You should see a complete launch plan followed by a complete assumption audit. At least three marked blockers should show why the original answer cannot yet support an objective or reproducible decision.

That is the trap exposed. Next, you will turn this weak baseline into a repeatable benchmark with evidence-based scoring.

Build a Repeatable Benchmark

Your retained ChatGPT conversation now contains a polished baseline plus an audit of its hidden assumptions. You have exposed why that first answer cannot serve as a trustworthy benchmark.

A fair comparison needs the same tests plus an explicit evaluation rubric for every response. This step turns your baseline into a repeatable method with evidence behind every score.

In this step, get ready to:

• Define a five-criterion rubric with fixed scoring anchors.
• Create a reusable packet containing three fictional benchmark prompts.
• Compare the baseline against a repaired response using quoted evidence.

Define the 20-point rubric

A score becomes reproducible when each number has a shared meaning. Five criteria worth four points each keep the method compact while covering answer quality from evidence to practical use.

• Send this prompt in the retained ChatGPT conversation:

Create a 20-point evaluation rubric for this conversation.

Use exactly these five criteria worth 0 to 4 points each:
- Grounding and correctness.
- Constraint adherence.
- Completeness.
- Calibrated uncertainty.
- Actionability.

For every criterion, define 0 as absent or unsupported. Define 2 as mixed or partially supported. Define 4 as strong and supported by visible evidence.

Format the rubric as a table. State that the maximum total is 20. Preserve this rubric for every response scored later in this conversation.

What do the anchors change?

• The five criteria separate different qualities that a polished answer can blur together.
• The fixed anchors give the same numbers a consistent meaning across model runs.
• The visible-evidence requirement ties every score to text that another person can inspect.

This project-authored rubric keeps your comparison consistent. OpenAI does not publish or endorse this 20-point scale.

• Leave the completed rubric in the retained conversation.
• Confirm that the table contains exactly five criteria.
• Confirm that every criterion defines the 0-point anchor.
• Confirm that every criterion defines the 2-point anchor.
• Confirm that every criterion defines the 4-point anchor.
• Confirm that the maximum total is 20.

You should see one rubric table covering grounding, constraints, completeness, uncertainty, and actionability. Each row should use the same three score anchors.

Does the rubric drift from the method?

• Ask ChatGPT to remove any extra criteria if the table contains more than five.
• Ask ChatGPT to restore the exact 0-point, 2-point, and 4-point meanings if it changes an anchor.
• Ask ChatGPT to regenerate the table if the total exceeds 20.

Need help checking the structure? Help me compare my rubric against the required five criteria and scoring anchors.

Create the three-prompt packet

A reusable packet holds its fictional facts constant while changing the skill being tested. This prevents factual differences between prompts from distorting the comparison.

• Generate the packet in the retained conversation by sending this prompt:

Create a reusable three-prompt evaluation packet. Do not answer the three tests yet.

Use these identical fictional facts in every test:
- The target learners are university students managing three to five courses.
- The product is a clickable browser prototype with no production backend.
- One teammate can build interfaces with JavaScript.
- The other teammate can conduct user research and write study content.
- The total budget is $500.
- The launch window is 14 days.
- The required deliverables are a responsive web MVP, task entry, a weekly study plan, and a launch recommendation.
- Success means at least 8 of 10 test learners can create a weekly plan in under five minutes without help.
- Reliable browser-notification support on the learners' devices is unknown.
- Do not invent user demand, notification support, legal approval, external integrations, or test results.

Return exactly three clearly labeled prompts:

Prompt 1, Multi-step planning. Require a complete launch plan that uses the supplied facts, respects the budget and timeline, covers every required deliverable, applies the success metric, flags the unknown, and avoids inventing prohibited facts.

Prompt 2, Instruction following. Request the same recommendation in a one-page format with exactly these sections: Recommendation, Plan, Risks, and Success Check. Set a maximum of eight actions.

Prompt 3, Calibrated uncertainty. Keep the same facts. Make reliable browser-notification support the decision-critical unknown. Require exactly these sections: Conclusions, Assumptions, and Questions.

Make every prompt self-contained so it can be copied into a future model conversation without extra context.

How does the packet stay fair?

• Prompt 1 tests whether the model can plan across several connected constraints.
• Prompt 2 tests whether the same recommendation survives a strict output structure.
• Prompt 3 tests whether the model separates known facts from a decision-critical unknown.
• The shared fictional facts make future model runs comparable.

• Keep the generated packet in the retained conversation.
• Check that the packet contains exactly three labeled prompts.
• Check that every prompt includes the same fictional facts.
• Confirm that Prompt 1 covers multi-step planning.
• Confirm that Prompt 2 uses four named sections with no more than eight actions.
• Confirm that Prompt 3 separates conclusions, assumptions, and questions.

You should now see three self-contained prompts that can be copied into another model conversation. The facts should remain identical across all three tests.

Are facts missing from a prompt?

• Ask ChatGPT to regenerate any prompt that depends on context outside the packet.
• Ask ChatGPT to copy every fictional fact into each prompt if a future run would otherwise need the earlier conversation.
• Ask ChatGPT to preserve the notification-support unknown if it resolves that fact without evidence.

Need help finding packet drift? Help me check whether my three prompts use identical fictional facts.

Run and score the repaired test

Prompt 1 repairs the missing context that weakened your baseline. Running it in the same conversation creates a direct before-and-after comparison for the model available on your Free account.

• Find Prompt 1 in the generated evaluation packet.
• Copy the complete Prompt 1 text.
• Paste Prompt 1 into the conversation's message field.
• Predict which rubric criterion will improve most.
• Send the pasted Prompt 1.

You should receive a repaired multi-step launch response that works from the supplied product facts. The response should flag the notification-support unknown instead of silently resolving it.

• Leave the complete repaired response in the retained conversation.
• Predict which response will earn the higher total score.
• Score both responses by sending this prompt:

Score two responses from this conversation using the 20-point rubric above.

Response A is the complete original answer to the intentionally vague study-planning-app launch prompt.
Response B is the complete response to Prompt 1 from the three-prompt evaluation packet.
Do not score the assumption audit as either response.

For each response, assign 0 to 4 points for every rubric criterion. Quote one concrete passage from that same response to justify every criterion score. If a response provides no supporting passage, quote the closest relevant passage and explain the gap.

Calculate each total out of 20. Compare the two results without changing the rubric after seeing the answers.

Begin with the Free Account Model Label recorded earlier in this conversation. Do not infer a different label. Treat these results as observations of only the model or mode available on this account. Do not present either score as a GPT-6 Astra result.

How does the evidence protect the score?

• Scoring both responses with one rubric keeps the comparison stable.
• A direct passage shows why each criterion received its points.
• The recorded account label limits the result to the model or mode you actually observed.
• The access note prevents the benchmark from becoming an unsupported GPT-6 Astra claim.

• Compare every quoted passage against its source response.
• Confirm that the baseline has five criterion-level scores.
• Confirm that the repaired response has five criterion-level scores.
• Confirm that both totals are shown out of 20.
• Confirm that every criterion score cites one direct passage from the relevant response.
• Correct any mismatched quote by replying with the relevant source passage.

You should now see two complete score breakdowns with ten criterion-level scores in total. Every score should point back to a passage that another person can inspect.

Do the quotes support the scores?

• Replace any paraphrased evidence with an exact passage from the relevant response.
• Remove any evidence copied from the assumption audit.
• Request a corrected calculation if the five criterion scores do not match the displayed total.

Need help auditing the score table? Help me check whether every score is supported by the quoted response passage.

That is the evaluation method locked in. Your polished baseline and repaired response now have an evidence trail that makes their strengths and gaps visible.

Your benchmark is ready to reuse. Next, you will add official capability and pricing evidence to compare GPT-6 Astra with the lower-cost model options.

Map the Model Options

Your evaluation packet now measures response quality against the same 20-point rubric. The retained ChatGPT conversation contains evidence for the model available to your account.

Benchmark quality alone cannot justify a model choice. You also need official facts about each option.

In this step, get ready to:

• Build a sourced four-model capability map.
• Separate API identity from ChatGPT product access.
• Document GPT-6 Astra limitations with official links.

Build the four-model capability map

Your benchmark measures answer quality for one task. A capability map adds the product facts needed to judge whether that quality fits a real workload.

What belongs in the map?

Create one row per model. Place an official source URL beside every factual value.

• Canonical model name plus API ID.
• Official positioning.
• Supported reasoning efforts.
• Input and output modalities.
• Available tools.
• Context window plus maximum output.
• Standard short-context input and output price per 1M tokens.

• Switch back to the retained ChatGPT conversation from earlier.
• Start a draft message for a Markdown table titled Four-Model Capability Map.

You should now see the map title in your unsent draft message.

• Add one row for GPT-6 Astra with API ID gpt-6-astra.
• Add one row for GPT-5.6 Sol with API ID gpt-5.6-sol.
• Add one row for GPT-5.6 Terra with API ID gpt-5.6-terra.
• Add one row for GPT-5.6 Luna with API ID gpt-5.6-luna.
• Add the columns from the map structure above.

Your draft should now show four named rows beneath the complete set of comparison columns.

• Switch back to the OpenAI model catalog tab to collect the GPT-5.6 family specifications.
• Transcribe the official values into the GPT-5.6 Sol, GPT-5.6 Terra, and GPT-5.6 Luna rows.

The three lower-cost rows should now contain official positioning and technical specifications copied from the catalog.

• Switch back to the GPT-6 Astra model page to collect its specifications.
• Transcribe the official values into the GPT-6 Astra row.

All four rows should now contain identity, positioning, reasoning, modality, tool, context, and output information.

• Switch back to the OpenAI API pricing page to collect the Standard short-context prices.
• Transcribe each model's input price and output price per 1M tokens.

Each row should now show a separate input price and output price for the same Standard short-context pricing scope.

• Add the relevant official URL beside every factual value in the draft.
• Send the source notes with a request for ChatGPT to format only your supplied facts without filling any gaps.

You should see a four-row capability map with all required columns. Every factual value should have a nearby official source URL.

Missing or unsupported values?

Return to the official page linked for that row if a cell is missing. Leave the cell unfilled until you find the value in the documentation.

Remove any value ChatGPT added without a source. Ask it to preserve your supplied facts without making inferences.

Need help locating a field in the official pages?

Separate model identity from product access

A model's canonical API identity stays fixed while product access can depend on your plan or rollout status. Keeping those facts separate prevents an availability claim from becoming an unsupported benchmark claim.

• Add an access note beneath the capability map.
• Record GPT-6 Astra's API ID as gpt-6-astra.

The access note should now begin with the canonical API identity from the model page.

• Switch back to the GPT-5.6 and GPT-6 Pro in ChatGPT article to confirm the product mapping.
• Record that GPT-6 Pro in Chat is powered by GPT-6 Astra.

Your note should now distinguish the Astra API model from the GPT-6 Pro option in Chat.

• Use the same official article to confirm the documented GPT-6 Astra rollout across ChatGPT Work and Codex.
• Record that availability can differ by plan, product, account permission, and rollout status.

The product-access section should now preserve the rollout caveat instead of promising universal access.

• Return to the GPT-6 Astra model page to inspect its API usage-tier table.
• Record that the table lists Free as Not supported.

The access note should now separate paid API availability from access inside ChatGPT products.

• Copy the Free Account Model Label you recorded earlier into the access note.
• Add a statement explaining that this label documents only the model or mode shown by your own account.

Your note should identify your observed Free-account label without treating it as evidence of GPT-6 Astra access.

Record the decision-relevant limitations

Model limitations affect whether an existing workflow can migrate cleanly. Recording them beside access facts keeps the future scorecard honest about what GPT-6 Astra can accept or control.

• Switch back to the GPT-6 Astra model guidance to inspect the migration limitations.
• Record that GPT-6 Astra does not support the none reasoning effort.

Your limitations note should now distinguish Astra's reasoning controls from those of the GPT-5.6 family.

• Record that migrations must remove custom temperature controls.
• Record that migrations must remove top_p controls.
• Record that migrations must remove top_logprobs controls.
• Record that Chat Completions migrations must also remove logprobs.

The migration section should now identify every documented sampling or log-probability control that requires removal.

• Return to the GPT-6 Astra model page to confirm its modalities.
• Record support for text input, text output, and image input.

The modality note should now show the interfaces the model accepts and produces.

• Record that audio input and video input are not supported.
• Return to the GPT-6 Astra model guidance to confirm the tool-calling requirement.

Your modality section should now make the unsupported inputs visible before a workload recommendation is made.

• Record that tool calling requires the Responses API.
• Add the relevant official source URL beside every limitation.

The completed limitations note should now connect every migration constraint to official guidance.

• Add a final statement explaining that you have not produced a hands-on GPT-6 Astra result on this account.

Before you inspect the finished artifact, which model do you expect to carry the highest Standard short-context token prices?

• Inspect the completed map for all four canonical names and API IDs.
• Check every row for the required capability and pricing fields.
• Verify that every factual value has an official source URL.
• Compare the access note with your recorded Free Account Model Label.
• Confirm that the limitations note contains every documented migration constraint from this step.

What should your completed map show?

The finished map should preserve one consistent pricing scope across all four rows. These are the Standard short-context prices currently shown in the official documentation.

• GPT-6 Astra uses API ID gpt-6-astra. It is positioned for the hardest end-to-end work. Its prices are $10.00 per 1M input tokens and $50.00 per 1M output tokens. Source: model page plus pricing page.
• GPT-5.6 Sol uses API ID gpt-5.6-sol. It is positioned for complex professional work. Its prices are $4.00 per 1M input tokens and $20.00 per 1M output tokens. Source: model catalog plus pricing page.
• GPT-5.6 Terra uses API ID gpt-5.6-terra. It is positioned as balancing intelligence and cost. Its prices are $2.00 per 1M input tokens and $12.00 per 1M output tokens. Source: model catalog plus pricing page.
• GPT-5.6 Luna uses API ID gpt-5.6-luna. It is positioned for cost-sensitive workloads. Its prices are $0.20 per 1M input tokens and $1.20 per 1M output tokens. Source: model catalog plus pricing page.
• The GPT-6 Astra row lists low, medium, high, xhigh, and max reasoning efforts. Its context window is 1,050,000 tokens. Its maximum output is 128,000 tokens. Source: GPT-6 Astra model page.
• The GPT-5.6 family rows list none, low, medium, high, xhigh, and max reasoning efforts. They list a 1.05M context window and 128K maximum output. Source: OpenAI model catalog.
• The access note distinguishes GPT-6 Astra from GPT-6 Pro in Chat. It records ChatGPT Work and Codex availability with rollout caveats. It also records Free as Not supported for the Astra API model. Sources: ChatGPT availability article plus GPT-6 Astra model page.
• The limitations note excludes none reasoning effort and custom temperature, top_p, top_logprobs, and logprobs. It records the modality restrictions and the Responses API requirement for tool calling. Source: GPT-6 Astra model guidance.

Strong work. Your model map now separates measured evidence from official product facts. Next, you will turn it into a one-page adoption scorecard.

Publish Your Adoption Scorecard

Your four-model map now gives every factual claim an official source. The final move is to use your retained ChatGPT conversation to turn that research into a recommendation someone can use.

Raw facts plus benchmark scores are hard to act on. This step converts them into a concise scorecard that keeps evidence, access, and uncertainty visible.

In this step, get ready to:

• Define candidate model logic across task complexity, end-to-end tool use, cost of an incorrect result, volume, latency sensitivity, and price sensitivity.
• Tie each recommendation to benchmark evidence, official claims, access status, and confidence.
• Format the reviewed material as a one-page Markdown scorecard.

Define the selection logic

A useful selection rule connects each workload to the capability level it needs. The six decision factors stop model prestige from deciding every row.

• Switch back to the retained ChatGPT conversation from earlier.
• Ask ChatGPT to create the decision table by sending this prompt:

Create a candidate model selection table from the Four-Model Capability Map and Benchmark Scores already in this conversation.

Use at least four workload rows. Include these decision columns: task complexity, end-to-end tool-use need, cost of an incorrect result, volume, latency sensitivity, and price sensitivity.

Use this starting logic:
- GPT-6 Astra for the hardest end-to-end work where its added capability is relevant.
- GPT-5.6 Sol for complex professional work.
- GPT-5.6 Terra for balancing intelligence and cost.
- GPT-5.6 Luna for cost-sensitive, high-volume work.

Label every recommendation as a task-specific candidate that still requires evaluation. Do not claim benchmark results for a model that was not tested.

How does this shape the decision?

• The six decision columns force each model choice to respond to workload conditions.
• The four starting positions preserve the official model positioning from your sourced map.
• The candidate label keeps every recommendation open to task-specific testing.

• Read each workload row in the generated table.
• Confirm each row contains all six decision factors.
• Confirm every recommendation is labeled as a candidate that still requires task-specific evaluation.

You should see four distinct candidate positions across GPT-6 Astra, GPT-5.6 Sol, GPT-5.6 Terra, and GPT-5.6 Luna. Each position should depend on the workload conditions.

Missing a decision factor?

If ChatGPT omits a column, ask it to revise the existing table using the six factors from your prompt. Keep the original workload rows unchanged so the comparison remains consistent.

Need help refining the table? Help me check whether my model selection table uses all six workload factors consistently.

Add evidence and uncertainty

A recommendation becomes defensible when someone can trace it to observed benchmark evidence plus an official capability claim. Access status and confidence reveal where the conclusion is limited.

• Revise the candidate table by sending this prompt:

Revise the candidate selection table. For every workload recommendation, add:
- relevant benchmark evidence from this conversation
- the matching official capability claim from the sourced Four-Model Capability Map
- current access status
- a confidence label

Keep observed benchmark evidence tied to the model actually tested on this Free account. Label GPT-6 Astra's benchmark status exactly: Not tested on this account. Do not transfer the Free model's score to GPT-6 Astra. Keep every recommendation framed as a candidate that requires task-specific evaluation.

What does this evidence add?

• Benchmark evidence anchors each recommendation to an observed result.
• The official capability claim shows why the candidate fits the workload.
• Access status separates documented availability from the model you tested.
• The confidence label communicates the strength of the recommendation.

• Compare every benchmark passage in the revised table with your Benchmark Scores from earlier.
• Check every capability claim against the Four-Model Capability Map from earlier.
• Verify every row states the relevant current access status.
• Confirm the GPT-6 Astra row uses the exact benchmark status Not tested on this account.

You should see evidence plus uncertainty in every recommendation. The score from your Free account should remain attached only to the model or mode you actually tested.

Evidence mixed between models?

If ChatGPT assigns your observed score to GPT-6 Astra, tell it to restore the tested Free-account model label from earlier. Ask it to reserve the Astra row for official claims plus the untested status.

Need help separating claims from results? Help me identify which scorecard statements are observed benchmark evidence and which are official capability claims.

Format and review the scorecard

The final artifact needs enough detail to support a decision while remaining readable on one page. Its five sections keep the comparison, evidence, rules, caveat, and sources easy to inspect.

• Turn the enriched table into the final artifact by sending this prompt:

Format the collected material in this conversation as a one-page Markdown GPT-6 adoption scorecard.

Use these section headings exactly:
# Model Map
# Benchmark Result
# Selection Rules
# Access Caveat
# Sources

Include at least four workload-type candidate recommendations. Preserve the decision columns for task complexity, end-to-end tool use, cost of an incorrect result, volume, latency sensitivity, and price sensitivity.

For every recommendation, include relevant benchmark evidence, an official capability claim, current access status, and a confidence label. Keep GPT-6 Astra benchmark status exactly as: Not tested on this account.

Use only facts and URLs already present in this conversation. Keep all model names, API IDs, standard short-context prices, limitations, and source URLs unchanged. Do not claim hands-on GPT-6 Astra results.

How is the page organized?

• The first two sections preserve the sourced map plus the observed benchmark result.
• The next two sections convert that evidence into selection rules plus an explicit access caveat.
• The final section gives each factual claim a path back to its official source.

Before you inspect the scorecard, do you expect every recommendation to survive a line-by-line check against the source tabs?

• Compare every model name plus API ID in Model Map with the Four-Model Capability Map from earlier.
• Compare every standard short-context price in Model Map with the pricing tab from earlier.
• Compare every GPT-6 Astra limitation in Access Caveat with the model guidance tabs from earlier.
• Check each URL in Sources against its matching official reference tab from earlier.
• Confirm Benchmark Result labels GPT-6 Astra as Not tested on this account.

The factual layer should now match the official pages plus your observed benchmark evidence. Any mismatch needs correction before the scorecard supports a decision.

The remaining review checks whether the page turns those facts into usable selection logic.

• Confirm the scorecard covers at least four workload types.
• Confirm Selection Rules includes all six decision columns.
• Confirm every recommendation includes relevant benchmark evidence.
• Confirm every recommendation includes an official capability claim.
• Confirm every recommendation includes current access status.
• Confirm every recommendation includes a confidence label.
• Confirm every recommendation remains a task-specific candidate that requires evaluation.

You made the evidence usable. Your one-page scorecard now links workload needs to model candidates while preserving the limits of your actual testing.

Scorecard longer than one page?

• Ask ChatGPT to remove repeated wording while preserving every required section.
• Keep every source URL intact when shortening the page.

Need help trimming the draft? Help me shorten my GPT-6 adoption scorecard without removing required evidence or caveats.

Secret mission

Test a Mid-Project Change of Direction

Change the study-app budget to $250. Shorten the timeline to 10 days while keeping every other fact fixed. Score the revision before preparing the same test for a future GPT-6 Astra run.

Clean Up Your Resources

This project created no paid resources, API data, or known local files that require deletion. Finishing the active session only requires closing its browser tabs.

• Close the ChatGPT Free browser tab that shows your evaluation workspace.
• Close each of the five official OpenAI reference tabs.
• Confirm that no project tabs remain open in your browser.

Nice Work!

Nice Work!

You did it! Your evidence-backed scorecard turns model claims into a decision a teammate can review.

What you learned:

• Built an intentionally weak baseline. Used an assumption audit to expose the missing facts behind its polished answer.
• Created a reusable three-prompt benchmark. Scored both responses with a 20-point evidence-based rubric. Supported every awarded score with direct passages.
• Built a sourced model map for GPT-6 Astra, GPT-5.6 Sol, GPT-5.6 Terra, and GPT-5.6 Luna. Turned that map into a one-page Markdown GPT-6 adoption scorecard with workload-based candidate recommendations. Distinguished the GPT-6 Astra API model from GPT-6 Pro in ChatGPT. Kept untested Astra results labeled Not tested on this account.
• Secret Mission: Added a scored requirement-change test for the tighter budget and timeline. Prepared a blank GPT-6 Astra future run column with identical prompts, rubric, and pass criteria.

Ready to quiz yourself?