OpenAI’s Codex coding environment can be configured to use a context window of around 1 million tokens with GPT-5.6 Sol, giving developers the ability to keep substantially more code, documentation and task information available to the model during long-running coding sessions. The capability was highlighted by OpenAI’s Tibo Sottiaux, who shared configuration instructions showing how developers can enable the larger context setting in Codex.
The development is significant for software engineers working on large repositories and complex agentic coding tasks. A larger context window can allow an AI coding agent to inspect more files and dependencies at once, reducing the need to repeatedly summarize or discard information from earlier parts of a task. However, the 1M-token capacity is a configurable option rather than a replacement for Codex’s default context setting, which has been tuned for performance and cost.
Codex Gets Access to a 1M-Token Context Window
GPT-5.6 Sol has a documented context window of approximately 1.05 million tokens at the model level.
The newly highlighted Codex configuration allows developers to take advantage of that larger capacity by changing settings in the Codex configuration file.
For developers, the practical significance is straightforward: the model can potentially retain far more information during a single coding task.
That information can include source code, configuration files, documentation, test results, command outputs and previous changes made during an extended session.
| Feature | Details |
|---|---|
| Coding environment | OpenAI Codex |
| Model | GPT-5.6 Sol |
| Maximum documented context | About 1.05 million tokens |
| Configurable Codex context | Up to around 1 million tokens |
| Main use case | Large codebases and long-running coding tasks |
| Configuration | Codex settings/configuration |
| Default context | Smaller and tuned for performance and cost |
Why a Larger Context Window Matters
Context is one of the most important limitations for AI coding agents.
A coding model does not simply need to understand the file currently being edited. It often needs information from multiple parts of a repository.
For example, changing a payment function may require the model to understand:
- The payment service
- Database schemas
- Authentication logic
- API routes
- Front-end components
- Tests
- Configuration files
- Documentation
- Deployment settings
With a smaller context window, an AI agent may need to summarize or compress earlier information before continuing.
A much larger context window reduces that pressure.
Large Repositories Could Benefit the Most
The biggest potential benefit is for developers working on large software repositories.
A small application may fit comfortably within a conventional context window.
A large enterprise codebase can contain hundreds or thousands of files, along with documentation, test suites and configuration.
Developers working on these projects often spend considerable time helping AI tools understand the architecture before asking them to make changes.
A larger context window can allow the model to inspect more of that architecture directly.
Codex Can Keep More Project Information Available
AI coding agents work differently from traditional autocomplete tools.
Instead of simply suggesting the next line of code, an agent can inspect a repository, identify relevant files, modify code, run tests and iterate on its changes.
That workflow requires persistent context.
The larger the task, the more information the agent may need to keep available.
A 1M-token context gives Codex considerably more room for these long-horizon tasks.
Traditional Coding Assistant
Open file
↓
Generate code
↓
Complete task
Large-Context Coding Agent
Understand repository
↓
Inspect dependencies
↓
Read documentation
↓
Plan changes
↓
Modify multiple files
↓
Run tests
↓
Read errors
↓
Fix problems
↓
Retest
↓
Review implementation
A larger context window can make the second workflow more practical for complex projects.
The 1M-Token Setting Is Not the Default
An important distinction is that developers should not assume every Codex session automatically operates with a 1M-token context.
The larger context is enabled through configuration.
The configuration guidance shared by Sottiaux explains how developers can adjust Codex settings to access the larger window.
The default context length remains smaller because OpenAI has tuned it for factors such as performance and cost.
This means the 1M-token option is better understood as an advanced capability for tasks that actually require it.
Why OpenAI Does Not Simply Max Out Context
More context is not automatically better for every coding task.
Processing larger amounts of information can increase computational requirements.
It can also affect response latency and cost.
For smaller coding tasks, loading an enormous amount of repository information may provide little benefit.
A developer fixing a typo or changing a single function may gain nothing from a million-token context.
For large architectural changes, however, the additional capacity can become valuable.
Context Window and Effective Context Are Different
The distinction between a model’s advertised context window and the context available in a specific product is important.
GPT-5.6 Sol’s model specification can support a context window of around 1.05 million tokens.
However, Codex has at different points used smaller effective context limits depending on the product configuration and implementation.
That means developers should check the context capacity available in their specific Codex version rather than assuming that the model’s maximum is always available.
The configuration update is therefore significant because it provides a way to access the larger capability where supported.
What Is a Token?
A token is a unit used by AI models to process text.
Tokens do not correspond directly to words.
A single word may represent one or more tokens, while punctuation and spaces can also contribute to token usage.
Code can consume tokens quickly because programming repositories contain large amounts of structured text.
A project with source files, comments, documentation, configuration and test output can therefore consume hundreds of thousands of tokens during a complex task.
One Million Tokens Represents a Huge Amount of Context
A context window of approximately one million tokens is large enough to accommodate an enormous amount of text and code.
The exact amount of source code that fits depends on the programming language, formatting, comments, file structure and other content.
Nevertheless, the difference between a few hundred thousand tokens and one million tokens can be substantial for large projects.
It can allow an agent to work with a much broader representation of a repository before it needs to summarize or discard information.
Long-Horizon Coding Could Become More Reliable
One of the potential advantages of larger context is improved continuity.
Suppose an AI agent is asked to refactor a large application.
The task may require changes across dozens of files.
With limited context, the model may lose track of decisions made earlier in the process.
That can result in inconsistent implementations.
A larger context gives the agent more room to retain earlier information and compare new changes against the original requirements.
This does not eliminate mistakes, but it can reduce one source of inconsistency.
Better Repository-Level Understanding
Large-context AI systems can potentially reason about software at the repository level rather than treating individual files as isolated tasks.
This matters because modern applications are highly interconnected.
A change to an API can affect the database layer.
A database change can affect backend services.
Backend changes can affect front-end components.
Tests and deployment configurations may also need to change.
Understanding these relationships is one of the biggest challenges for AI coding agents.
Testing Could Benefit From Larger Context
Large coding tasks often involve an iterative process.
The agent writes code, runs tests, receives errors and then makes additional changes.
The test output becomes part of the task’s context.
A larger window allows more test results and previous attempts to remain available.
That can help an agent understand whether a new error is related to a recent change or an existing problem elsewhere in the project.
Documentation Can Stay in Context
Software projects often have extensive documentation.
Architecture guides, API specifications, contribution rules and internal development instructions can be important when modifying code.
With a smaller context, developers may need to manually provide these documents or rely on retrieval mechanisms.
A larger context can allow more documentation to remain available alongside the source code.
This can make it easier for an AI agent to follow project-specific rules.
The Capability Could Change AI-Assisted Software Development
The move toward larger context windows is part of a broader evolution in AI coding tools.
Early coding assistants focused primarily on autocomplete.
Modern systems are becoming increasingly agentic.
They can navigate repositories, execute commands, modify multiple files and perform iterative debugging.
As these agents become more capable, context becomes increasingly important.
The ability to understand an entire project can be just as important as the ability to generate high-quality individual functions.
Large Context Does Not Mean Perfect Code
A larger context window does not automatically make an AI coding agent accurate.
The model can still misunderstand requirements, introduce bugs, choose poor architectures or make incorrect assumptions.
More information can also create new challenges.
If a repository contains contradictory documentation or outdated code, providing more of it does not necessarily improve the answer.
Developers therefore still need to review generated changes and run appropriate tests.
Developers Still Need Human Oversight
AI coding agents can accelerate development, but human review remains important.
Developers should verify:
- Security-sensitive code
- Database migrations
- Authentication logic
- Payment systems
- Infrastructure changes
- Dependency updates
- Production configuration
- Data-handling practices
A large context helps an AI understand more information, but it does not remove the need for engineering judgment.
Cost and Performance Remain Trade-Offs
Using a larger context can require more computational resources.
For companies running AI coding agents at scale, that can affect costs.
Performance can also vary depending on how much information is included.
A model that receives a massive amount of context may take longer to process a task than one working with a smaller, carefully selected context.
This is one reason why the larger context is best treated as an option rather than a universal default.
Context Compression Remains Important
AI coding systems often use techniques such as summarisation and compaction to manage long-running sessions.
These mechanisms allow an agent to preserve important information while reducing the amount of raw context it needs to carry forward.
A larger context window reduces the frequency with which such compression may be necessary, but it does not make context management irrelevant.
For extremely long tasks, intelligent context selection can remain important even with a million-token window.
Codex Is Moving Toward Larger Agentic Tasks
The development reflects OpenAI’s broader push to make Codex capable of handling increasingly complex software-engineering workflows.
The goal is moving beyond simple code generation toward systems that can operate more like software-development agents.
That includes understanding requirements, navigating repositories, writing code, executing tests and responding to failures.
A larger context window provides an important foundation for this direction.
Competition in AI Coding Is Intensifying
OpenAI is competing in an increasingly crowded AI coding market.
Developers have access to tools from multiple major AI companies and specialised coding startups.
The competition is no longer simply about which model writes the best code.
Developers also care about:
- Repository understanding
- Context length
- Tool use
- Terminal access
- Agent reliability
- Speed
- Cost
- IDE integration
- Security
- Enterprise controls
The ability to handle larger projects could become an important differentiator.
Large Context Could Matter for Enterprise Customers
Enterprise software repositories can be particularly large and complicated.
They often include years of accumulated code, extensive documentation and numerous internal dependencies.
Enterprise customers also have strict requirements around security and compliance.
If AI agents can understand larger portions of these environments without constant manual guidance, they could become more useful for large-scale development teams.
The Bigger Opportunity Is Autonomous Engineering
The long-term significance of larger context goes beyond simply fitting more code into a prompt.
It enables AI agents to maintain a richer understanding of a software project while performing multiple steps autonomously.
That could eventually allow agents to take on larger portions of routine engineering work.
Developers could spend more time defining requirements, reviewing architecture and validating results while AI agents handle more implementation and debugging tasks.
What Developers Should Watch
Developers using Codex should pay attention to several factors as larger context options become available.
These include:
- Actual context available in their Codex version
- Performance at high context sizes
- Token consumption
- Response latency
- Context-compaction behaviour
- Code quality on large repositories
- Reliability across long-running tasks
- Cost of using larger contexts
The best configuration will depend on the size and complexity of the project.
Key Facts at a Glance
| Metric | Details |
|---|---|
| Tool | OpenAI Codex |
| Model | GPT-5.6 Sol |
| Maximum documented model context | About 1.05 million tokens |
| Configurable context | Around 1 million tokens |
| Configuration method | Codex configuration settings |
| Primary benefit | Larger repository-level context |
| Best suited for | Large codebases and complex agentic tasks |
| Default setting | Smaller, performance- and cost-tuned context |
| Main trade-offs | Compute, latency and cost |
| Human review | Still required |
Infographic: How the 1M-Token Codex Context Changes Coding
GPT-5.6 SOL
↓
CODEX
↓
CONFIGURATION SETTING
↓
UP TO ~1 MILLION TOKENS
↓
MORE CODE + DOCUMENTATION
↓
MORE PROJECT CONTEXT
↓
BETTER REPOSITORY-LEVEL UNDERSTANDING
↓
COMPLEX MULTI-FILE TASKS
↓
CODE
+
TESTS
+
DOCUMENTATION
+
DEPENDENCIES
+
COMMAND OUTPUTS
↓
LONGER AGENTIC WORKFLOWS
↓
POTENTIAL BENEFITS
LESS MANUAL CONTEXT SHARING
+
FEWER CONTEXT RESETS
+
BETTER TASK CONTINUITY
+
LARGER SOFTWARE PROJECTS
↓
BUT
↓
HIGHER COMPUTE REQUIREMENTS
+
POTENTIAL LATENCY
+
HIGHER COST
↓
HUMAN REVIEW REMAINS ESSENTIAL
The Bigger Picture
OpenAI’s move to make a roughly 1 million-token context available in Codex with GPT-5.6 Sol represents another step in the evolution of AI coding agents. Instead of focusing only on individual functions or files, developers can potentially give the agent access to much larger portions of a software project. That can be particularly valuable for large repositories where architecture, dependencies, documentation and test results all need to be considered together.
The capability also highlights the changing nature of competition in AI coding. Context length is becoming one part of a much broader equation that includes agent reliability, tool use, cost, speed and repository-level reasoning. The 1M-token option does not guarantee better code and is not necessarily useful for small tasks, but it could give developers working on complex projects a much larger workspace for AI-assisted software engineering.
Looking Ahead
The immediate impact will likely be strongest among developers working with large repositories and long-running Codex sessions. As the configuration becomes easier to use, developers will be able to test whether the additional context improves multi-file refactoring, debugging, architectural analysis and other complex workflows. The practical value will depend not only on the size of the context but also on how effectively Codex selects and reasons over the information it receives.
Over the longer term, larger context windows could help AI coding agents move closer to acting as full software-engineering collaborators. However, context size will remain only one piece of the puzzle. Reliability, security, cost, latency and the ability to make sound engineering decisions will ultimately determine how much responsibility developers are willing to delegate to AI coding agents.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
