OpenAI has officially updated its developer documentation, introducing the GPT-6 Sol model as the default solution for powering advanced agents. The new engine offers a massive context window exceeding one million tokens, but it also introduces a rigorous fee system that may surprise AI system designers.
A new step in the evolution of OpenAI models
The official OpenAI materials now include the technical specification for a new model called GPT-6 Sol. According to the released documentation, the creators designed it with coding tasks and autonomous software agent workflows in mind. OpenAI is positioning it as the default model for these use cases, signaling a move to unify the ecosystem around a single, specialized engine with high reasoning capabilities. On the documentation page, this model is described with two labels: Highest Reasoning and Fast Speed.
Technical specification: One million token context and modality limitations
The most impressive aspect of the GPT-6 Sol specification is the size of its context window. It stands at exactly 1,050,000 tokens. This allows for loading entire code repositories, extensive technical documentation, or hundreds of pages of legal documents into the cache simultaneously. Meanwhile, the maximum output token count is 128,000 tokens, enabling the generation of long blocks of text or code without the need to split responses into smaller fragments.
However, it is worth noting what the model can and cannot process. GPT-6 Sol supports both text and images as input. We can therefore send it screenshots of user interfaces, flowcharts, or graphs. At this moment, there are clear limitations:
- Text-only output: The model does not directly generate graphics, audio, or video.
- No audio or video input support: Sending audio files or video recordings directly to GPT-6 Sol is impossible. For such tasks, it is necessary to use other API endpoints or auxiliary models.
- Knowledge cutoff: The model's knowledge ends on April 20, 2026. Everything that happened later is inaccessible to it, unless we provide that information in the context window or use web search.
New OpenAI pricing: The long context trap
An analysis of the GPT-6 Sol pricing structure shows that OpenAI is trying to promote efficient cache management while imposing high fees on users who thoughtlessly send massive amounts of data. The base rates per million text tokens are as follows:
- Standard Input: 2.00 USD
- Cached input: 0.20 USD (which is exactly 10% of the base rate)
- Cache writes: 2.50 USD (1.25x the base rate)
- Output: 10.00 USD
Using the cache mechanism allows for significant savings if we repeatedly query the model about the same dataset (e.g., the same code library). However, if we exceed a certain threshold, costs will rise drastically. OpenAI has introduced a special threshold for long queries.
Queries that contain over 272,000 input tokens are charged double for input and cache, while the rate for output tokens increases by 1.5x in these cases.
This is an important change for agentic system designers. It means that sending a query with a context size of, for example, 300,000 tokens will cost significantly more per token than sending a query of 250,000 tokens. Developers will need to implement precise context-trimming mechanisms or aggressive cache usage to avoid financial surprises.
Impact of processing modes on costs
The final cost of using the GPT-6 Sol API also depends on the selected processing mode and geographic location:
- Batch and Flex modes: Offer a 50% discount compared to standard rates. They are ideal for tasks that do not require an immediate response (e.g., nightly log analysis or mass code refactoring).
- Fast mode: Guarantees the lowest possible latency but costs twice as much as standard rates.
- Regional processing: If we choose to process in a specific region (where this option is available), we will pay a 10% premium on the base price.
- EU data residency: This is available only in the standard processing mode, which may limit the ability to use cheaper Batch/Flex options for companies subject to strict legal regulations in Europe.
API tools and integrations: What can GPT-6 Sol do?
The model is equipped with native support for a wide range of tools and functions via the new Responses API standard. This makes it easier to build applications that not only answer questions but also perform tasks in operating systems or networks.
Among the supported tools and functions, we find:
- Hosted Shell: Allows the model to execute commands in a secure, isolated console environment.
- Apply patch: A tool created directly for automatically applying changes to source code based on generated fixes.
- Computer use: A feature allowing the model to interact with the graphical interface of operating systems, making it resemble a human operator.
- MCP (Model Context Protocol): An open standard for connecting the model to external tools and data sources.
- Web search and File search: Tools for searching the web and local document collections to supplement the model's knowledge in real-time.
- Code interpreter and Image generation: Classic tools for executing Python code and generating graphics (the GPT-6 Sol model itself returns only text, while graphics are created by a separate tool invoked via the API).
It is also worth mentioning the API endpoints. GPT-6 Sol works with almost the full portfolio of OpenAI services, including Live, Chat Completions, Realtime (along with real-time translation and transcription), Assistants, and Batch. Interestingly, Fine-tuning also appears on the list of supported endpoints, but the technical documentation for the GPT-6 Sol model explicitly states that fine-tuning is not supported for this specific model.
Important limitations and technical nuances
When implementing GPT-6 Sol in your projects, you must keep in mind several limitations that may affect application architecture. The most important is the specific operation of the Function calling feature. When using the Chat Completions endpoint, function calling is supported only when the reasoning_effort parameter is set to none.
This means you cannot simultaneously use the model's deep, multi-step reasoning (which is its main advantage) and direct generation of structured function calls in a single step. Developers will be forced to design multi-step chains, where in the first step the model performs advanced reasoning, and in the next—with low reasoning priority—it generates the appropriate API call.
Additionally, for tool-specific models (such as web search or computer operations), OpenAI charges a separate fee for each tool call. These costs add up to the fees for consumed tokens, which can generate significant expenses during intensive agent work. The security of such operations also remains an open question, as well illustrated by recent OpenAI 2026 cybersecurity audits, which point to the need for rigorous control over permissions granted to autonomous scripts.
What does this mean for developers and the AI market?
The appearance of GPT-6 Sol in OpenAI's documentation clearly defines the development direction for the second half of 2026. We are moving from simple chatbots to autonomous agents capable of working with large software projects. The ability to use the hosted shell, the MCP protocol, or the Apply patch tool makes this model a viable candidate for the role of an independent junior developer in development teams.
Competition in this field is fierce, however. Google is promoting its agents as part of the Gemini agentic era, and developers seeking coding alternatives are increasingly turning to Anthropic's Claude models. OpenAI's move to release GPT-6 Sol with such a large context window and native support for operating systems is a direct response to these challenges.
Whoever learns to effectively use the cache and avoid the double-billing trap above 272,000 tokens will gain access to unprecedented computing power without the risk of bankrupting the project.
Comments