GPT-6.1 Sol is available starting today to all Plus, Pro, Business, Enterprise, and Edu users in ChatGPT Work and Codex, where it delivers practical intelligence for complex coding, computer use, and professional work. The model nearly matches GPT-6 Astra’s intelligence on agentic coding, computer use, and professional work at one-fifth of Astra’s standard API input and output token prices. This guide walks you through exactly how to access and use it effectively in both environments, from selecting the model to structuring your first task.
GPT-6.1 Sol at a Glance
GPT-6.1 Sol is the updated Sol-class model in OpenAI’s GPT-6 family that OpenAI describes as a model for complex coding, computer use, and professional work when you want near-Astra capability at a lower cost.
| Question | Answer |
| What is GPT-6.1 Sol? | Mid-tier reasoning model for complex coding, debugging, computer use, and professional work |
| Where is it available? | ChatGPT Work, Codex, and OpenAI API |
| Is it available in regular ChatGPT Chat? | No, it is not yet available in Chat |
| What is it designed for? | Agentic coding workflows, computer use tasks, multi-step professional work |
| Can developers use it in Codex? | Yes, GPT-6.1 Sol is available in Work and Codex on eligible plans |
| Does it have reasoning levels? | Yes, reasoning. effort supports low, medium (default), high, xhigh, and max |
| What pricing applies? | $2.00 per million input tokens and $10.00 per million output tokens, with cached input at $0.10 per million (50% discount) |
What Is GPT-6.1 Sol?
GPT-6.1 Sol is OpenAI’s mid-tier reasoning model in the GPT-6 series, released on September 29, 2026, as an upgrade to GPT-6 Sol. OpenAI says GPT-6.1 Sol delivers significant improvements over its predecessor GPT-6 Sol across complex tasks, including programming and debugging, understanding documents, and executing multistep workflows.
The model fills a practical gap: it performs near-identically to GPT-6 Astra on many coding and professional tasks but at substantially lower cost. The model improves factual accuracy when given difficult prompts, and GPT-6.1 Sol cuts factual errors and better follows safety limits compared to earlier Sol versions.
Reasoning is always on with GPT-6.1 Sol; it does not support no or minimal reasoning effort. This means every interaction includes reasoning tokens, which affects pricing and latency.
Where Can You Use GPT-6.1 Sol?
GPT-6.1 Sol in ChatGPT Work
GPT-6.1 Sol is available to all Plus, Pro, Business, Enterprise, and Edu users in ChatGPT Work. Work is OpenAI’s environment for longer, multi-step professional tasks where you want finished deliverables, analysis across documents, or structured outputs.
Common Work use cases include analyzing policy documents, synthesizing research across multiple PDFs, structuring business recommendations, generating technical specifications, and conducting computer use tasks that span multiple steps across applications.
GPT-6.1 Sol in Codex
GPT-6.1 Sol is available in Codex for software development and engineering workflows. Codex is available as the ChatGPT desktop app, the CLI, and an IDE extension. In an interactive CLI session, use /model to switch models or adjust reasoning effort.
Codex specializes in repository-aware development: inspecting codebases, implementing features across multiple files, refactoring, debugging production issues, and running tests.
GPT-6.1 Sol via the OpenAI API
Developers can access GPT-6.1 Sol through the OpenAI API using the model ID gpt-6.1-sol. This is separate billing and access from ChatGPT Work and Codex.
How to Use GPT-6.1 Sol in ChatGPT Work
Step 1: Open ChatGPT Work
Launch the ChatGPT desktop app or navigate to chatgpt.com and select Work from the left sidebar. Access depends on having an eligible plan: Plus, Pro, Business, Enterprise, or Edu.
Step 2: Open the Model Picker
In the ChatGPT desktop app and ChatGPT on the web, look for the model and reasoning control beneath the composer. By default, you see preset power levels: Balanced, Smarter, or Faster, depending on your account.
Step 3: Select GPT-6.1 Sol
Open Advanced to choose a specific model, reasoning effort, or speed. Select GPT-6.1 Sol from the model dropdown. If GPT-6.1 Sol doesn’t appear, your plan or workspace may not have access yet (see the troubleshooting section below).
Step 4: Choose the Reasoning Level
Reasoning effort supports low, medium (default), high, xhigh, and max. Here’s how to decide:
- Light (Low): Quick, well-defined tasks like writing emails, summarizing a single document, or answering straightforward questions.
- Medium (Default): Balanced choice for most professional work, moderate document analysis, or multi-step workflows.
- High/Extra High: Complex analysis across multiple documents, evaluations with competing considerations, or strategic recommendations requiring detailed reasoning.
- Max: Reserve for your most demanding work. Higher reasoning increases latency and token usage.
Compared to original GPT-6 Sol, which topped out at 68.8% at max reasoning effort, GPT-6.1 Sol achieves 75.2% at higher reasoning settings, gaining 6.4 percentage points over its predecessor at a lower reasoning effort and cost. Start with Medium or High and increase only if initial results lack sufficient depth.
Step 5: Give Work a Structured Task
Effective prompts follow this structure: Goal + Context + Inputs + Constraints + Deliverable + Acceptance Criteria.
Example:
“You are a technical strategist. I need you to analyze three competing cloud architecture proposals (files attached) and produce a structured recommendation memo. Context: We’re migrating a monolithic application with 500K daily users; downtime costs $10K per minute. Evaluate each on migration speed, cost, scalability, and risk. Your deliverable is a 2-page memo with a ranked recommendation, key risks per option, and a 90-day rollout outline. Accept only recommendations that address zero-downtime requirements.”
This prompt is specific enough that GPT-6.1 Sol understands what success looks like without inventing details.
How to Use GPT-6.1 Sol in Codex
Step 1: Open Codex and Select GPT-6.1 Sol
In the ChatGPT desktop app, CLI, or IDE extension, use the model and reasoning control to choose GPT-6.1 Sol. Via CLI, use:
bash
codex –model gpt-6.1-sol
Or within an interactive session:
bash
/model gpt-6.1-sol
Step 2: Give Codex Repository Context
Unlike a generic coding assistant, Codex works best when you provide rich context:
- Repository location or code samples
- Framework and language
- Build system and package manager
- Relevant file structure
- Existing architecture patterns
- Testing framework and test commands
- Known constraints (performance budgets, browser support, security requirements)
- Coding conventions and naming patterns
- Recent changes or dependencies to avoid
Example:
“This is a Next.js 14 TypeScript monorepo using Turborepo. The auth service is in /apps/auth-service; the main app is in /apps/web. We use Vitest for tests and pnpm for package management. The team follows strict immutability patterns for state and uses React Query for server state. The codebase is on Node 18+. I need to add OAuth 2.0 with PKCE flow for Google. Don’t modify the existing auth context; extend it.”
Step 3: Ask Codex to Inspect Before Editing
This is the critical difference between using Codex effectively and generating untested code.
“First, inspect the current auth service structure. Understand how tokens are stored, refreshed, and validated. Then plan the OAuth implementation: which files change, which are new, and which configuration is needed. Finally, show me your plan before implementing.”
This inspection step helps Codex understand your codebase patterns and prevents breaking changes.
Step 4: Implement the Change
After Codex proposes a plan, give it the go-ahead with clear acceptance criteria:
“Implement the OAuth 2.0 PKCE flow. New code must: (1) follow existing error handling patterns, (2) add comprehensive TypeScript types, (3) include tests for the OAuth callback and token refresh. Don’t modify existing auth tests; add new ones in /tests/oauth.test.ts.”
Step 5: Run Tests
Never skip this step. After implementation, ask Codex to run your test suite:
bash
codex exec “npm run test”
Review the output. If tests fail, ask Codex to fix failures with specific context:
“The OAuth test is failing at the token validation step. The test expects the refresh token to be set; the implementation is missing it. Fix the implementation.”
Step 6: Review the Changes
Before merging, inspect diffs carefully. Ask Codex to summarize changes:
“Show me a summary of all files modified. For each change, explain why it was necessary and highlight any potential side effects.”
Review for:
- Unintended changes to unrelated code
- Missing error handling
- Security issues (e.g., token exposure, CORS misconfigurations)
- Breaking changes to public APIs
- New dependencies and their security posture
This workflow (Inspect → Plan → Implement → Test → Review) turns Codex into a real engineering partner instead of a code generator.
Read More: How to Use GPT-6 Astra to Build 3D Assets & Animations in Blender
Best GPT-6.1 Sol Prompts for Work and Codex
Professional Work Prompt
“Analyze the attached Q3 financial reports from our three business units and produce a consolidated executive summary. Include: (1) revenue and margin performance versus plan, (2) top three cost drivers per unit, (3) three strategic priorities for Q4, and (4) risk flags requiring executive attention. Format as a structured memo suitable for the board. Accept only analysis grounded in the provided data.”
Repository Analysis Prompt
“You’re joining our team and need to understand this codebase quickly. Inspect the repository structure, identify the main service boundaries, explain the data flow from API entry points through to the database, and list the three most critical files I should understand first. Assume I know the tech stack but not our conventions.”
Coding Prompt
“Implement an exponential backoff retry mechanism for failed API calls in /services/api-client.ts. Requirements: (1) exponential backoff with jitter, (2) configurable max retries (default 5) and base delay (default 100ms), (3) respect HTTP 429 Retry-After headers, (4) log each retry with context, (5) don’t retry on 4xx errors except 429. Add TypeScript types. Write tests in /tests/api-client.test.ts.”
Debugging Prompt
“This production issue started at 14:32 UTC. The logs show timeout errors in the payment processing queue. Inspect the queue service code, identify the likely root cause, propose a fix, implement it, and add a test that would catch this regression. Walk me through your reasoning at each step.”
Code Review Prompt
“Review the implementation in the attached diff. Look for: (1) bugs or logic errors, (2) security issues (SQL injection, XSS, token exposure), (3) potential regressions or breaking changes, (4) performance problems, (5) maintainability issues. For each finding, explain the risk and propose a fix. Prioritize by severity.”
These prompts work because they define success explicitly and provide the context Codex needs to reason accurately.
What Can You Use GPT-6.1 Sol for?
| Use Case | How GPT-6.1 Sol Helps |
| Debugging | Identify root causes in logs, propose fixes, implement and test solutions |
| Refactoring | Safely improve code while preserving behavior; run tests to verify equivalence |
| Feature Development | Implement requirements across multiple files while respecting architecture patterns |
| Testing | Generate comprehensive test cases; improve coverage for edge cases and error paths |
| Code Review | Identify bugs, security issues, regressions, and maintainability problems |
| Repository Analysis | Understand unfamiliar codebases; trace data flow; identify service boundaries |
| Documentation | Update technical documentation to match implementation changes |
| Professional Work | Analyze documents; synthesize insights; produce structured deliverables |
| Computer Use | Execute multi-step workflows across applications (where supported) |
OpenAI says GPT-6.1 Sol improves on GPT-6 Sol in programming, debugging, document understanding, and multi-step workflows, making it particularly effective for these tasks.
GPT-6.1 Sol Reasoning: Which Level Should You Use?
Reasoning effort is available at low, medium (default), high, xhigh, or max, with quality, latency, and cost trade-offs.
| Task Complexity | Suggested Reasoning |
| Simple edits, quick fixes | Low reasoning |
| Standard coding tasks, routine analysis | Medium (default) |
| Complex debugging, multi-step workflows | High reasoning |
| Difficult engineering problems requiring trade-off analysis | Extra High (xhigh) |
| Extremely demanding work where quality is paramount | Max (reserve for critical paths) |
The key insight: GPT-6.1 Sol beats GPT-6 Sol’s best DeepSWE score at a lower reasoning effort and cost. You don’t need to always max out reasoning. Start with Medium or High and increase only if results are insufficient.
GPT-6.1 Sol vs GPT-6 Sol vs GPT-6 Astra
All three are reasoning models in the GPT-6 family. Understanding the differences helps you choose:
| Model | Positioning | Key Trade-off |
| GPT-6.1 Sol | Near-Astra performance at one-fifth the token cost | Best for repeated, intensive work across code and documents |
| GPT-6 Sol | Earlier Sol model; slower to reason, higher costs | Upgrade to 6.1 Sol for better results at lower cost |
| GPT-6 Astra | Highest intelligence for the most demanding reasoning | Use when quality is paramount and cost is secondary |
Model selection should depend on your task, available budget, speed requirements, and required capability. For complex work you want to run more often, GPT-6.1 Sol gives you near-Astra performance at a substantially lower cost.
GPT-6.1 Sol Performance: What the Official Evaluations Show
On DeepSWE v1.1, GPT-6.1 Sol achieves 75.2% at higher reasoning settings, beating GPT-6 Sol’s best score of 68.8% at max reasoning effort, at approximately 76% lower cost per task.
On OSWorld 2.0, at maximum reasoning effort, GPT-6.1 Sol scores 71.4%, outperforming GPT-6 Sol (64.4%) by 7.0 percentage points while reducing compute cost by more than half.
On professional document analysis (GDP.pdf), GPT-6.1 Sol achieves 32.0% at higher reasoning settings, beating Claude Opus 5.5 with fallbacks (28.8%) while cutting task cost by more than 50%.
On AutomationBench 1.0.6 multi-step business workflows, at medium reasoning effort, GPT-6.1 Sol scores 35.4%, approximately 2.2 percentage points above Claude Opus 5.5 at medium reasoning effort, while costing approximately one-third as much per task.
These benchmarks measure specific test environments. Your real-world results will depend on how well your task aligns with the evaluation, the quality of your prompts, and whether you’ve provided adequate repository or document context.
Why Can’t I See GPT-6.1 Sol?
GPT-6.1 Sol is missing from the model picker
Check these first:
- Plan eligibility: GPT-6.1 Sol is available in ChatGPT Work and Codex on Plus, Pro, Business, Enterprise, and Edu plans. If you have a Free plan, upgrade to Plus first.
- Workspace settings: Organization admins may have restricted model availability. Check with your workspace administrator.
- Rollout progress: While GPT-6.1 Sol is available starting today to all eligible users, gradual rollouts sometimes apply to specific regions or workspaces. Try again in a few hours.
- Admin permissions: If your organization uses workspace controls, your admin may need to enable GPT-6.1 Sol for your team.
I only see GPT-6 Sol or other models
This typically means your plan has access to earlier models but not yet to GPT-6.1 Sol. Check your plan details in Settings.
Is GPT-6.1 Sol available in regular ChatGPT?
GPT-6.1 Sol is not yet available in Chat. It’s currently limited to Work and Codex. If you need GPT-6.1 Sol for a task, use Work or Codex.
Best Practices for Using GPT-6.1 Sol in Work and Codex
- Define the desired outcome explicitly. Be specific about what success looks like. “Debug the payment queue” is vague; “Fix the timeout error in payment processing. Success means the queue processes 1000 items per minute without errors” is clear.
- Provide relevant context. More context is usually better. Paste relevant code snippets, file structures, or document excerpts rather than summaries.
- Give acceptance criteria. Tell GPT-6.1 Sol how you’ll judge the result. This prevents hallucinated details.
- Ask Codex to inspect before modifying. Never let Codex start implementing without understanding your codebase first.
- Require tests for code changes. Don’t accept code without tests.
- Use appropriate reasoning effort. Medium is a good default; increase only when results are insufficient.
- Break complex work into verifiable stages. Instead of “build this system,” ask for design first, then implementation, then testing.
- Review diffs and outputs carefully. AI-generated code is code; treat it like any other pull request.
- Avoid unnecessary context. Extremely long prompts with irrelevant details can reduce reasoning quality.
- Keep humans responsible. Final decisions on technical direction, security, and production changes remain with your team.
Common Mistakes to Avoid
- Vague instructions: “Fix the bug” doesn’t work. “The login endpoint returns 500 errors after the database migration. Identify the root cause and implement a fix that preserves backward compatibility” does.
- Large changes without repository context: Asking Codex to refactor 10 files without describing your architecture will likely produce inconsistent results.
- Skipping inspection: Jumping straight to implementation without understanding existing code patterns leads to inconsistent or breaking changes.
- Skipping tests: Generated code is not production-ready without testing.
- Maximum reasoning by default: Start with Medium or High; you’ll save on costs and latency without sacrificing quality for most tasks.
- Trusting benchmarks as guarantees: OpenAI’s benchmarks measure specific test environments, not your actual workload.
- Assuming Work and Codex are identical: Work is for professional multi-step tasks; Codex is for software development. Use the right tool.
- Availability depends on plan: GPT-6.1 Sol requires Plus, Pro, Business, Enterprise, or Edu. Free users need to upgrade.
Conclusion
GPT-6.1 Sol is available to Plus, Pro, Business, Enterprise, and Edu users in ChatGPT Work and Codex, delivering near-Astra capability for a fraction of the cost. Work suits longer professional tasks requiring structured analysis or document synthesis. Codex suits software development with full repository awareness and testing integration.
Effective results depend on clear task definition, adequate context, appropriate reasoning levels, and human review before shipping. Medium is the default reasoning effort, and most tasks don’t require maximum; start there and adjust based on results.
Your next step: Open ChatGPT Work or Codex on your eligible plan, select GPT-6.1 Sol from Advanced model settings, and try it on a task that matters to your work. The model performs best when you’re specific about what success looks like.
Frequently Asked Questions
What is GPT-6.1 Sol?
GPT-6.1 Sol is the updated Sol-class model in OpenAI’s GPT-6 family that OpenAI describes as a model for complex coding, computer use, and professional work when you want near-Astra capability at a lower cost.
How do I use GPT-6.1 Sol in ChatGPT Work?
Open ChatGPT Work on the web or desktop app. Click the model picker beneath the composer. Select Advanced and choose GPT-6.1 Sol from the dropdown. Adjust reasoning effort as needed. Then write your task prompt.
How do I use GPT-6.1 Sol in Codex?
Launch Codex in the desktop app, CLI, or IDE extension. Use the model picker to select GPT-6.1 Sol, or use codex –model gpt-6.1-sol at the command line. Provide repository context, ask Codex to inspect, plan, implement, test, and review.
Is GPT-6.1 Sol available in regular ChatGPT Chat?
No, GPT-6.1 Sol is not yet available in Chat. Use Work for professional tasks or Codex for development.
Is GPT-6.1 Sol good for coding?
Yes. On DeepSWE v1.1, GPT-6.1 Sol achieves 75.2% at higher reasoning settings, outperforming GPT-6 Sol significantly at lower cost. It’s particularly strong for complex refactoring, debugging, and multi-file implementations.
What is the difference between GPT-6.1 Sol and GPT-6 Sol?
GPT-6.1 Sol is an upgrade to GPT-6 Sol that achieves higher scores on benchmarks at lower reasoning effort and cost. GPT-6.1 Sol improved factual accuracy and safety compliance.
Can GPT-6.1 Sol work with a code repository?
Yes. Provide Codex with your repository structure, framework, build system, and coding patterns. It will understand your codebase and implement changes consistently.
What reasoning levels does GPT-6.1 Sol support?
GPT-6.1 Sol supports low, medium (default), high, xhigh, and max reasoning effort. It does support none or minimal reasoning.
Why can’t I see GPT-6.1 Sol in ChatGPT Work or Codex?
Check your plan (Plus, Pro, Business, Enterprise, or Edu required), verify your workspace doesn’t restrict the model, and check if a rollout is still in progress in your region.
Should I use GPT-6.1 Sol or GPT-6 Astra?
For your most demanding work, choose Astra when maximizing quality matters most. For complex work you want to run more often, GPT-6.1 Sol gives you near-Astra performance at a substantially lower cost.