A workshop organiser wants to add online booking to her website. Visitors should choose a class, reserve a seat and receive a confirmation.
It sounds like one feature. But several questions sit underneath it. What happens when a class fills up? Can someone cancel? What if two people try to book the last seat at the same time?
An AI that writes a convincing description of the feature has completed only part of the work. The team still needs working software, sensible handling of these situations and evidence that it behaves correctly.
GPT-6 Sol is designed for complex coding and agent workflows. That makes it relevant to work that involves several connected steps. An “agent” is an AI application equipped with tools to carry out tasks.
The useful question is how well it can turn the team’s request into a result they can inspect.
Meet GPT-6 Sol
| Profile detail | What it means |
|---|---|
| Model | GPT-6 Sol |
| Provider | OpenAI |
| Family | GPT-6 |
| Tier / model line | Sol |
| API identifier | gpt-6-sol |
| Released | September 22, 2026 |
| Main focus | Complex coding and agent workflows |
The API identifier is the name software uses to request this particular model. “Sol” identifies the model line, not a subscription plan.
There is also a newer GPT-6.1 Sol, released on September 29, 2026. This article profiles the original GPT-6 Sol and explains the newer alternative later. Keeping their names separate matters because their settings and features are not identical.
Where Sol fits beside Luna and Astra
Writing, coding and tool use appear across several models. A long list of shared features does little to explain which one fits your work.
Sol’s position becomes clearer when we compare its focus and ordinary API prices with its neighbours.
| Model | OpenAI’s positioning | Input / output price per million tokens |
|---|---|---|
| GPT-6 Luna | Focused tasks at high volume | $0.10 / $0.50 |
| GPT-6 Sol | Complex coding and agent workflows | $2 / $10 |
| GPT-6 Astra | The most demanding work | $10 / $50 |
These are standard rates for requests with up to 272,000 input tokens. A token is a small unit used to process information; in text, it may be a word, part of a word or punctuation.
For the workshop business, Luna could be tested on a focused task such as sorting enquiries by class. Sol could be tested on implementing the booking feature and checking how it behaves. Astra could be compared on a larger redesign involving conflicting requirements across several systems.
Those are practical examples of where to begin testing, not measured results or limits on what the models can attempt.
Sol’s lower token price than Astra is clear. Whether it gives better value for your task still needs evidence.
What working with GPT-6 Sol could look like
Suppose the team provides the current website, a picture of the proposed booking screen and a short list of requirements.
A useful first step would be to identify decisions that affect the build. If cancellation rules are missing, the assistant should flag the gap. Quietly inventing a rule could leave the business with behaviour it never intended.
Next, the assistant could plan the work: inspect the existing website, add seat availability, build the reservation flow and check the result. Through suitable tools, it could then edit files and run tests. The application executes those actions and returns the results to the model.
The most revealing test might be the last available seat. Two people attempt to reserve it. Does exactly one booking succeed? A feature that looks good on screen can still fail this check.
This is an illustrative workflow. It shows how planning, tool use and verification could fit together; it is not a claim that Sol has completed this particular task.
The tools make the difference
Sol’s documented Responses API tools include web and file search, code interpreter, hosted shell, apply patch, computer use, MCP, tool search, skills and image generation.
In practical terms, a configured application can search information, run calculations or commands, edit files and interact with a screen. These connections can support coding, research, document, data and business-workflow agents.
A research assistant might gather evidence for a report. A document assistant might find relevant passages before answering. A business assistant might draft an update to a customer record.
Each needs the right connections. Being able to describe an action does not mean the model has access to perform it.
What the specifications mean in everyday work
| Specification | GPT-6 Sol |
|---|---|
| Direct inputs | Text and images |
| Direct output | Text |
| Context window | 1,050,000 tokens |
| Maximum output budget | 128,000 tokens |
| Listed knowledge cutoff | April 20, 2026 |
These are documented model specifications.
Think of the context window as working space for the task. It can hold instructions, reference material and conversation content. More space can help when a project has many files, but it does not guarantee that the model notices every important detail.
The maximum output budget also needs interpretation. Reasoning tokens count towards generated output and billing, so the visible answer can be much shorter than the limit suggests.
Sol offers reasoning-effort settings from none to max, with medium as the default. This allows developers to adjust the amount of reasoning work. The best setting is the one that meets the task’s quality needs at an acceptable time and cost.
The model also supports structured output: an agreed format with consistent fields. For a test report, that might mean “test performed,” “result” and “remaining issue.” Consistent formatting helps another application use the response, but does not prove the contents are correct.
What needs to be connected before it can work
An API is a way for software systems to communicate. A business can run its application on a company server or cloud service and connect it to the hosted model.
For the booking project, that application would need access to the approved website files and somewhere to run tests. A separate test environment lets the team examine changes before customers encounter them. A sandbox can restrict the files, websites and actions available.
OpenAI offers different approaches to running agents, including a developer-controlled Agents SDK. An SDK is a toolkit for building software. In this arrangement, the developer controls the application’s tools, storage and approval process.
For developers using Sol, the Responses API is the route for built-in tools and reasoning with tool calls. Its Chat Completions function calling is supported only with reasoning effort set to none. This compatibility detail can affect an existing integration.
MCP, another connection standard, can help link an AI application to tools and data. It does not grant access by itself. The connected service still needs authentication and appropriate permissions.
The workflow also needs a starting signal. That could be a person’s request, an approved new task, a schedule or a business event. Asking the model to “check bookings every morning” does not create the scheduler required to run that job.
Remembering work and sharing it between agents
During the booking task, the assistant needs access to the requirements and decisions already made. To continue on another day, the application must save and restore relevant information.
OpenAI’s Conversations API can preserve conversation items across sessions. That is different from the model permanently remembering everything.
Preferences such as the company’s writing style can be stored separately. Company knowledge, such as cancellation policies, can be retrieved from approved documents when needed. These are choices in the application’s memory design.
The team could also divide the work between agents. One might build the feature while another checks it against the requirements. OpenAI’s Agents SDK supports specialist handoffs and using agents as tools.
This coordination is called orchestration. A single agent may be sufficient. A fixed sequence can organise predictable stages; a supervising agent can assign specialist work; independent checks can run in parallel. Events can start any of these arrangements.
More agents create more results to reconcile. If one assumes cancellations are allowed and another assumes they are blocked, the team has created a new problem. Shared requirements and clear ownership matter more than the number of agents.
How much freedom should the application have?
The same model can operate with very different levels of autonomy.
It might only advise the team, prepare work for human review, complete approved steps before pausing, or finish a tightly defined task within preset limits. Selecting Sol does not choose those boundaries.
For the booking project, a reasonable starting design is to allow changes in the test environment while requiring approval before publishing them. The reviewer should see what changed, which checks passed and what remains unresolved.
Access should match the job. An account allowed to edit website files does not automatically need customer payment details. Separate permissions for reading, editing, sending and deleting reduce what a mistaken action can affect.
A dedicated software account, often called a service account, can make this separation clearer. Assign access by responsibility and keep it limited to what the workflow needs.
OpenAI’s computer-use guidance recommends restricted environments, confirmation for consequential actions and verification of the actual outcome. Written instructions should be supported by controls in the application.
Where mistakes can become expensive
A coding model can propose a plausible change that is wrong. In the workshop example, it might let visitors reserve full classes, misunderstand a cancellation rule or change an unrelated part of the website.
Tools add another dimension. An agent could edit the wrong file, repeat a failing step, spend money on unnecessary calls or attempt an action outside its authority. In a team of agents, one incorrect assumption can spread.
External content creates another risk. A page or document might contain instructions telling the assistant to reveal information or visit an unrelated website. This is prompt injection: content trying to redirect the agent. Treating that material as untrusted input helps preserve the original task boundaries.
A practical recovery plan should specify when to retry, restore an earlier version, save progress, ask for help or stop. Before repeating a timed-out booking action, check whether it succeeded. Otherwise, a retry could create a duplicate reservation.
Set limits on time, spending and unsuccessful attempts. Keep a record of the original request, sources, changes, tool outcomes, approvals and errors. Those records should explain what happened without exposing passwords or unnecessary customer information.
Someone should own the workflow and decide its data, review and retention rules. Model selection alone does not establish that the complete system meets the organisation’s requirements.
What happens to private information?
OpenAI states that API data is not used for training unless the customer opts in. However, abuse-monitoring logs and stored application state have their own retention rules. Default abuse-monitoring retention is generally up to 30 days, with documented exceptions.
For the workshop project, test bookings may be enough. There may be no reason to upload the real customer list.
Check the terms of every connected service, too. An application calling an email provider or an external database introduces another place where information can be processed.
What GPT-6 Sol actually costs
The short answer is $2 per million ordinary input tokens and $10 per million output tokens at standard, shorter-input rates.
The fuller picture includes reused input and longer requests.
| Charge per million tokens | Up to 272,000 input tokens | Above 272,000 input tokens |
|---|---|---|
| Ordinary input | $2 | $4 |
| Cached input read | $0.20 | $0.40 |
| Cache write | $2.50 | $5 |
| Output | $10 | $15 |
Caching lets a system reuse eligible previously processed input. Creating the cache and reading it have different rates. For requests above the threshold, the longer-input rates apply to the full request.
For a simple example, 100,000 ordinary input tokens cost $0.20. Another 10,000 billable output tokens cost $0.10. That gives a $0.30 model charge before additional services.
An agent task can involve many requests. Searches, connected services, a browser or computer environment, runtime and human review can all add to the cost. API charges are also separate from a ChatGPT subscription.
The useful business measure is cost per accepted result. If a trial costs $30 and produces 60 results that pass review, each accepted result costs $0.50. This is an illustrative calculation, not a Sol performance claim.
How to tell whether it is helping
For the workshop organiser, the result is a reliable booking experience. A large amount of generated code is not the measure of success.
First, define what correct work looks like. That includes reserving available seats, preventing overbooking, handling cancellations as specified and protecting customer information.
Then measure the agent’s performance. Track how often it completes tasks correctly, how often its actions work, whether it selects the right tools, how many steps it takes and how long it runs. Also record failures, successful recovery, human intervention, escalations and cost per accepted task.
Business outcomes answer a different question. Did the feature take less time to deliver? How much checking and correction did people perform? Did booking errors or manual administration decrease?
Compare models using the same requirements, tools and checks. Otherwise, a better result may come from better instructions or access rather than from the model itself.
When Sol is worth considering, and when to look elsewhere
Sol is a candidate for tasks where several steps must fit together and the result can be checked. Examples include building a defined feature, investigating a software issue, reviewing an implementation against requirements or preparing a report from approved sources.
A focused, repetitive task may justify testing Luna first. A particularly difficult investigation may justify comparing Astra. A spreadsheet formula or ordinary rule may already solve some jobs reliably.
Sol’s documented limitations also matter: native audio and video are not supported, and fine-tuning is not listed as supported. An application needing those capabilities must use a suitable additional service or another model.
The newer alternative: GPT-6.1 Sol
OpenAI describes GPT-6.1 Sol as delivering near-Astra performance at lower cost. That is the provider’s positioning, not a guarantee for every task.
Its standard input and output prices are also $2 and $10 per million tokens. Cached input reads are $0.10, compared with the original Sol’s $0.20. GPT-6.1 Sol also removes the none reasoning setting and requires the Responses API for tool calling.
The release announcement separately documents a native multi-agent beta for 6.1. This should not be confused with an application coordinating agents through an SDK.
For someone starting a new evaluation, the newer version belongs in the comparison. For an existing workflow, check behaviour and compatibility before changing the model.
The decision should come back to the work: which option produces an acceptable result with the least overall expense and correction?
Questions readers may still have
Do you need to know coding to use it?
A suitable application can accept ordinary-language requests. Building a custom connection to company systems generally needs technical setup. Reviewing generated software also requires relevant expertise.
Will it know the company’s booking rules automatically?
No. Supply the rules or connect an approved source. If a rule is missing, the assistant should flag the gap.
Can it make a working feature without any human checking?
An application can give an agent considerable freedom, but completion is not proof of correctness. Checks and review should match the consequences of a mistake.
Is GPT-6 Sol only useful for coding?
Coding is a central documented focus. With appropriate tools and information, possible applications also include research, document analysis and business workflows. Test each application against its own success criteria.
Sources and verification
Last verified: September 30, 2026.
Specifications, prices and release details were checked against official OpenAI documentation. The workshop-booking story, suggested uses and operating controls are illustrative. No independent benchmark or hands-on model comparison is claimed.