OpenAI GPT-6.2 Astra explained: what it changes for teams
What GitHub shipped on November 17, 2026
GitHub made OpenAI's GPT-6.2 Astra and GPT-6.2 Sol generally available in GitHub Copilot on November 17, 2026, and access is limited to Copilot Pro+, Max, Business and Enterprise users, as the GitHub changelog entry states. For a small B2B software company the practical change is narrower than the headline: the two models appear in coding tools your developers already open, they are billed by usage at each model's published rate, and anyone on Copilot Pro cannot select them.
TL;DR: Astra is the model GitHub describes for agentic coding and terminal work, and Sol is the model it describes for complex agentic coding and in-depth code review. GPT-6 Astra and GPT-6.1 Sol are the earlier versions to compare against, and the decision that matters this month is plan access and admin rollout, not the interface.
In plain terms, GPT-6.2 is a version number within OpenAI's GPT-6 family, and Astra and Sol are the two variants GitHub lists for coding and code review. The billing you pay under has also changed, which matters for any comparison. Since June 1, 2026, Copilot charges token usage at the model's published API rate instead of counting premium requests, and InfoWorld's April analysis describes the old limit as 300 monthly premium requests for Pro, with overages at $0.04 each, according to InfoWorld (2026).
Key Takeaways
GitHub made GPT-6.2 Astra and GPT-6.2 Sol generally available on November 17, 2026, but not for Copilot Pro users.
Astra's list rate is 20% below GPT-6 Astra's on both input and output tokens, while Sol's list rate matches GPT-6.1 Sol's.
The changelog says Astra uses fewer tokens and Sol catches more review issues, but the launch entry gives no per-task cost and no benchmark score.
Business and Enterprise admins control rollout through model policy, and new models are enabled by default unless an admin turns that off.
Plan access is the first cost decision, because the models draw on each plan's monthly AI credits.
For most small teams this month, the right step is an admin check and a capped pilot on one review workflow, not a migration.
How we evaluated these models
We scored the choice on six criteria a small team actually decides on, weighted by how often each one changes whether the models are usable and what they cost. The weights are our judgment, not a vendor metric, and the table states what each criterion rests on. Plan access carries the most weight, because a model a developer cannot select has no cost or quality to compare.
| Criterion | Weight | What it decides | Rests on |
|---|---|---|---|
| Plan access for your team | 30% | Whether a developer can select the models at all | Plan table in GitHub's plans documentation |
| Per-token list rate | 20% | Cost per million tokens against the models they replace | GitHub's models-and-pricing table |
| Included credits and budget control | 15% | How much usage a seat covers before extra billing | Plan credit allowances and admin budget caps |
| Admin rollout control | 15% | Whether new models switch on by default | Model policy text in the changelog |
| Vendor's stated coding and review claims | 10% | Direction of quality gains, self-reported | Changelog wording |
| Predictability of monthly spend | 10% | How hard the bill is to forecast | Token-based billing described in trade press |
Feature matrix: Astra, Sol, and the models they replace
The table below puts the two new models beside the two earlier versions GitHub lists. Every rate is per 1 million tokens, at the default tier up to 272K input tokens unless the row says otherwise.
| Feature | GPT-6.2 Astra | GPT-6.2 Sol | GPT-6 Astra | GPT-6.1 Sol |
|---|---|---|---|---|
| Default input | $8.00 | $2.00 | $10.00 | $2.00 |
| Default cached input | $0.40 | $0.10 | $1.00 | $0.10 |
| Default cache write | $10.00 | $2.50 | $12.50 | $2.50 |
| Default output | $40.00 | $10.00 | $50.00 | $10.00 |
| Long-context input (above 272K) | $16.00 | $4.00 | $20.00 | $4.00 |
| Long-context output (above 272K) | $60.00 | $15.00 | $75.00 | $15.00 |
| Plan access in the launch entry | Pro+, Max, Business, Enterprise | Pro+, Max, Business, Enterprise | Not stated in the sources opened | Not stated in the sources opened |
| Vendor's stated review claim | Caught significantly more issues than GPT-6 Astra | Caught nearly twice as many real issues as GPT-6.1 Sol | Baseline for the Astra claim | Baseline for the Sol claim |
Every rate in the table is listed on GitHub's models page.
GPT-6.2 Astra input rate: $8.00 per 1M tokens according to GitHub Models Docs (2026), which works out to 20% below GPT-6 Astra's $10.00 input rate and 20% below its $50.00 output rate, shown as $40.00 for Astra.
The review claims are the vendor's own and are comparative. The changelog says Astra "caught significantly more issues in code review than GPT-6 Astra" and completed agentic tasks with "noticeably fewer tokens." For Sol it says the model "caught nearly twice as many real issues in code review as GPT-6.1 Sol while keeping its findings accurate," which is a bold claim: Sol review claim: nearly twice GPT-6.1 Sol according to GitHub Changelog (2026). The entry does not say how many issues, which codebases, or how accuracy was measured, so treat the claim as a direction rather than a number to budget against. For a separate look at token efficiency on the earlier model, see our GPT-6 Astra token efficiency comparison.
Rollout is gradual, and the changelog tells users to check back if the models are not yet in the model picker. The entry names Visual Studio Code, Visual Studio, Copilot CLI, the coding agent, the Copilot app, github.com, GitHub Mobile on iOS and Android, JetBrains IDEs, Xcode and Eclipse as selection surfaces. It does not state regional availability, and the vendor has not published it.
Pricing and plan access
Pricing checked November 17, 2026. Plan access is the first filter: the changelog lists Pro+, Max, Business and Enterprise, and GitHub's plans documentation marks both new models as not included on Pro. Individual prices come from the same plans page, and the Pro+ monthly allowance is Pro+ monthly allowance: 7,000 AI credits according to GitHub Plans Docs (2026).
| Plan | Monthly price | Included AI credits | GPT-6.2 Astra and Sol included | Best fit |
|---|---|---|---|---|
| Pro | $10 | 1,500 | No | One developer on everyday agent work without the new models |
| Pro+ | $39 | 7,000 | Yes | One developer who needs the new models |
| Max | $100 | 20,000 | Yes | One heavy user running sustained agent workflows |
| Business | $19 per seat | 1,900 per user | Yes | Small teams that want admin model policy and pooled credits |
| Enterprise | $39 per seat | 3,900 per user | Yes | Teams that need enterprise-level controls |
Plan prices and credit allowances in the table are from GitHub's plans documentation. The launch entry gives no per-task price, so any per-task figure in this article is a worked example, not a vendor number.
One AI credit is worth one cent, which means the Pro+ allowance is $70 of usage. Code completions and Next Edit suggestions are included without consuming credits, according to ITPro (2026), so the credit math applies to the premium models rather than to autocomplete.
Worked example, using assumed numbers rather than measurements: suppose one Pro+ engineer runs 100 review passes a month, each started by a pull_request event with the synchronize action, and each pass reads 50,000 input tokens and writes 5,000 output tokens on GPT-6.2 Astra at the default rates above. Input comes to 5,000,000 tokens, or 5 million at $8.00, which is $40.00. Output comes to 500,000 tokens, or 0.5 million at $40.00, which is $20.00. The month totals $60.00, or 6,000 credits at one cent each, which fits inside the 7,000 credits Pro+ includes and leaves 1,000 credits. Cached input would lower the total, and any run above 272K input tokens would raise it, and the example ignores all other Copilot usage.
For a Business team, the seat price is the fixed part. Business includes $19 in monthly AI Credits per seat, and GitHub is pooling credits across an organization, with admins able to set budget caps at the enterprise, cost-center and user levels, according to ITPro (2026). A hypothetical ten-seat Business team pays $190 a month in seat fees before any usage beyond its pooled allowance, and the one-engineer example above would use more than a single Business seat's 1,900 credits, so pooling and budget caps decide the real cost.
Who this is for
This is for a small B2B software company whose developers already use GitHub, and for an operations or engineering lead who has to decide within a month whether the review queue or the agent work justifies extra per-token spend. It is not for a team whose developers all sit on Pro, because the models are not on that plan.
Red flags: all your developers are on Copilot Pro, so the models are not available to them; you expect AI review comments to post to production without a named person approving them; or nobody owns the monthly usage budget.
Choose GPT-6.2 Astra if your main coding work is multi-step agent tasks in a terminal or agent. Choose GPT-6.2 Sol if review depth is the bottleneck. That split follows GitHub's own descriptions and is our reading, not a result we measured.
Vendor profiles: where each model fits
GPT-6.2 Astra
Best fit: teams whose coding is mostly agentic and terminal-based, which is the use the changelog names for this model. Limitations: it is not included on Pro, and once input passes 272K tokens the long-context rate applies, which GitHub's table lists at $16.00 input and $60.00 output. Implementation: choose it in the model picker on the listed surfaces, after a Business or Enterprise admin has set model policy. Evidence: the changelog's wording that it "completed agentic coding tasks using noticeably fewer tokens" than GPT-6 Astra, which is a vendor statement without a task count.
GPT-6.2 Sol
Best fit: teams whose main AI spend is code review, which the changelog describes as "in-depth code review." Limitations: its list rate matches GPT-6.1 Sol's, so the case for it rests on the quality claim, not on a lower price, and the "nearly twice" figure is self-reported. Implementation: the same plan gate and admin policy as Astra; a team that already runs GPT-6.1 Sol can compare the two on its own review queue before changing defaults.
GPT-6 Astra and GPT-6.1 Sol: the versions to compare against
GPT-6 Astra lists at $10.00 input and $50.00 output per million tokens, which matches the standard pricing reported at its September launch, according to Constellation Research (2026). Constellation reports that OpenAI first offered GPT-6 Astra to a select group before broad availability, and that it is positioned for computer use and software engineering. GPT-6.1 Sol shares its per-token rates with GPT-6.2 Sol, so the Sol decision is about the review claim. The launch entry does not say whether GPT-6 Astra's review performance differs from GPT-6.2 Astra's beyond the comparison it gives. For a separate look at accuracy on the earlier models, see our hallucination and accuracy comparison.
When NOT to use US Tech Automations
A managed workflow is the wrong purchase in three cases. If your team only wants a model inside the IDE, the model picker already covers that, and no workflow is needed. If your developers are on Copilot Pro and will stay there, the new models are not on their plan, so the workflow question waits until the plan changes. If one engineer reviews a handful of pull requests a month, a manual review in the picker is simpler and cheaper to run than a workflow with logs and approvals. US Tech Automations only earns its setup time when review volume and approval rules are already written down.
Where a managed review workflow fits
A proposed, configurable workflow would start when GitHub sends a pull_request webhook with the opened or synchronize action, the activity types listed in GitHub's webhook event reference. It would fetch the diff, send it to a model account the team controls, and write a draft review to a run log rather than to the pull request. Prerequisites: a repository token with read access, a model account that offers the models you intend to use, and a log store the team can read. The launch entry describes only Copilot surfaces, so the vendor has not published an API route for these models in an outside workflow, and that must be confirmed before anyone designs around it. US Tech Automations would configure the trigger, the draft log and the approval step as settings, so the design can be reviewed before any model call is made.
The human review point is the part buyers skip. A named engineer approves each draft before anything is posted, and a draft that fails twice goes to the engineering lead rather than into a retry loop. The same design could also listen for pull_request_review events with the submitted action, so the team can compare each draft with the final human review after four weeks. That comparison is the only evidence the team will have about the vendor's claims for its own code, and US Tech Automations would configure it as a weekly export that the reviewer can read.
Before each run, the same workflow could read the month's usage and pause when the remaining allowance drops below a level the owner sets, then notify that owner. The prerequisite is a usage export the team can read. The launch entry does not describe one, so confirm it before promising the pause.
Zapier, Make and n8n can run the same trigger-and-post chain, and they can support run histories, retries, error branches and audit evidence when configured. The buyer still designs and owns observability, idempotency (so a re-sent webhook does not post two reviews), escalation, access controls and maintenance. The table below sets the two build paths side by side.
| Capability | Zapier, Make or n8n, when configured | In-house build |
|---|---|---|
| Run history | Kept by the platform's run logs | Built and stored by your team |
| Retries | Configured as step retries | Written and tested by your team |
| Error branches | Configured as branches on failure | Written by your team |
| Audit evidence | Exportable logs when configured | Designed and retained by your team |
| Idempotency | Designed into the flow | Designed into the code |
| Escalation | Routed to a person by a configured step | Built by your team |
| Access controls | Set per account and per connection | Set per service account |
| Maintenance | Your team owns flows and updates | Your team owns code and updates |
Signal vs Speculation
Signal (confirmed on pages opened for this article):
GitHub's changelog dated November 17, 2026 says both models are generally available in Copilot for Pro+, Max, Business and Enterprise users.
GitHub's plans documentation marks both new models as not included on Pro.
GitHub's models page lists per-token rates for GPT-6.2 Astra, GPT-6.2 Sol, GPT-6 Astra and GPT-6.1 Sol.
Rollout is gradual, and regional availability has not been published.
Speculation (our reading):
Fewer tokens per task could lower the real cost of review-heavy work, but the vendor gave no per-task figure, so the saving is unknown.
Sol fits review-heavy teams and Astra fits agent-heavy teams; this follows the vendor's descriptions, and we did not test either model.
A managed workflow pays off only after a four-week comparison of drafts against final human reviews.
Gaps: our research did not surface an OpenAI launch page, so the launch facts here rest on GitHub's changelog and documentation. The vendor has not published a benchmark score, a per-task cost, or an API route for these models in outside workflows.
Glossary: the terms in the launch and the bill
Agentic coding: work in which the model plans and carries out several steps, such as editing files or running commands, with less input from the user at each step.
AI credit: GitHub's unit for paid-plan usage, where one credit equals one cent and each plan includes a monthly allotment.
Cached input: input tokens the model can reuse from a recent request, billed at a lower rate than fresh input.
Cache write: the charge for storing input so it can be reused, listed separately in GitHub's rate table.
Long-context tier: the higher rate that applies once a request's input passes 272K tokens, per GitHub's rate table.
Model policy: the admin setting that decides which models a Business or Enterprise organization can use, with new models enabled by default unless an admin turns that off.
Per-token billing: charges calculated from input, output and cached tokens at each model's published rate.
This month's decision checklist
- Confirm each developer's plan. Copilot Pro users do not get GPT-6.2 Astra or Sol.
- Business and Enterprise admins: open model policy and set the default for new models before a developer selects one.
- Set a budget cap at the user or cost-center level before the first month of use.
- Choose one review workflow to pilot, and write down who approves each output.
- Log every draft and the final human decision for four weeks.
- Ask GitHub for a per-task cost or usage export before forecasting a budget, since the launch entry gives neither.
Common questions about GPT-6.2 Astra
Can I use GPT-6.2 Astra on Copilot Pro?
No, the launch entry lists Pro+, Max, Business and Enterprise, and GitHub's plans documentation marks both new models as not included on Pro.
Which model should a review-heavy team pick?
Pick GPT-6.2 Sol if review depth is the bottleneck, because GitHub describes it for in-depth code review, and pick Astra if most of the work is multi-step agent tasks in a terminal. This is our reading of the vendor's descriptions, and the vendor has not published a head-to-head review benchmark.
Does GPT-6.2 Astra cost less than GPT-6 Astra?
On GitHub's list rates, yes: $8.00 per million input tokens against $10.00, and $40.00 per million output tokens against $50.00. The vendor has not published a per-task cost, so the real saving depends on how many tokens each task uses. For a separate look at API pricing, see our GPT-6 Astra API price comparison.
Do code completions use credits?
No, code completions and Next Edit suggestions are included in subscriptions without consuming credits.
What must a Business or Enterprise admin do?
Check model policy this week. New models are enabled automatically unless an administrator has turned off the global default or explicitly disables them, so an admin who wants to review first has to act before developers select the models.
Should you act this month?
For most small teams, the decision this month is an admin and budget check, not a platform change. Confirm which developers are on Pro+ or a higher plan, decide the model-policy default for any Business or Enterprise seats, and run one pilot on a review step where drafts can be compared with the final human review after four weeks.
If the review queue is already a bottleneck and you want the draft, approval and log trail without building it yourself, see how US Tech Automations configures this as a proposed workflow, with the prerequisites and approval points named before anything is built.
About the Author

Helping businesses leverage automation for operational efficiency.