Major coding update doubles qualified context to ~256K tokens, connecting more code, tests, requirements and diagnostics while preserving everyday quality.
San Francisco, CA · United States (PRUnderground)November 13, 2026
Pervaziv AI today introduced Cortex Code 2.0, extending the coding intelligence in Cortex to handle larger, more connected software engineering tasks with substantially more relevant code, requirements, tests, configuration and diagnostic context kept in view throughout the work.
A software change rarely lives in one file. A feature may begin with a requirement, depend on an interface elsewhere in the repository, behave differently under configuration, affect multiple callers and ultimately be judged by tests created long before the current change. The visible edit may be small. Understanding the change is not.
Cortex Code 2.0 expands its qualified context range from approximately 128K to approximately 256K tokens. The additional capacity allows substantially more relevant source code, tests, requirements, configuration and diagnostic evidence to remain available within a single engineering task.
The release is not simply about accepting a larger prompt. It is about giving the coding capability enough qualified working room to understand more of the relationships that make software changes difficult.
In controlled release qualification, Cortex Code 2.0 achieved a 90.3% aggregate pass rate across its long context suite, with every evaluated range meeting release criteria. The matched standard task suite retained a 100% pass rate with zero percentage point regression, and the release passed qualification through the live Cortex product path.
“The hard part of software engineering is rarely generating one more file. It is understanding how requirements, interfaces, implementations, configuration and tests fit together before changing any of them,” said Anoop Jaishankar, Founder and CEO of Pervaziv AI. “Cortex Code 2.0 keeps more of that connected problem in view. Complex work gets more room when it needs it, while everyday coding stays focused and responsive. That is the direction of Cortex: specialized intelligence that grows deeper where the work demands it, without making every task carry unnecessary weight.”
Software Engineering Is a Connected Problem
Many AI coding interactions begin with a narrow unit of work: explain this function, update this test, fix this error or modify this file.
The harder problems begin when the answer depends on what is not immediately visible.
A shared library upgrade can affect an interface, several implementations, configuration defaults and tests. A production defect can appear in one service while the cause sits in a shared utility, configuration override or downstream component. A large refactor may need to preserve an architectural contract across packages. A migration can introduce a new API while still protecting compatibility for existing consumers.
These are relationship problems.
Cortex Code 2.0 is designed to keep more of those relationships available at the same time. Developers can bring a larger connected body of evidence into the work so Cortex can reason about the change surface rather than treating each file as an isolated event.
That can mean keeping requirements beside the implementation they govern, tests beside the behavior they protect, or configuration beside the code and callers it influences. The result is a broader view of the software problem without changing the basic developer experience.
From a Specialized Ensemble to Deeper Specialists
Cortex Code 2.0 builds on the evolution of the Cortex AI Model Ensemble, Pervaziv AI’s architecture for assigning different forms of engineering intelligence to specialized responsibilities.
The Ensemble was designed around the idea that coding, planning, analysis, routing, security, privacy and verification should not all be collapsed into one model role.
Throughout 2026, Cortex Verify added independent validation for AI assisted code changes. Cortex Router added intent aware routing across specialized capabilities. Cortex Planner added structured execution planning. Cortex Routing Decisions and Cortex Security Decisions then became the tenth and eleventh specialized models, adding a dedicated decision layer for routing and software security judgments.
Cortex Confidential became the twelfth specialized model, adding semantic privacy and egress risk intelligence inside confidential workflows while deterministic controls retained final authority over what information could leave the protected environment.
Cortex Code 2.0 advances the Ensemble differently.
It does not add another specialist. It makes one of the existing core specialists substantially more capable within its own responsibility.
Cortex Code remains responsible for software engineering intelligence. Planning, analysis, security, privacy and verification retain separate roles around that work. A stronger coding specialist can produce a more complete technical result while the rest of the Ensemble continues to plan, investigate, constrain and independently verify it.
The strategy is not to make every model do everything. It is to make each responsibility stronger while preserving the boundaries between them.
Approximately Twice the Qualified Context
The most visible change is the expansion from approximately 128K to approximately 256K tokens of qualified context, roughly doubling the earlier range.
The customer value is not the number by itself. The value is what can remain connected inside that range.
For a multi component feature, that may include requirements, interfaces, implementations and tests. For a difficult defect, it may include symptoms, logs, callers, configuration and expected behavior. For a migration, it may include the new contract, compatibility constraints and affected code. For a refactor, it may include architectural intent and dependent components.
Longer requests also carry instructions that need to remain relevant throughout the work: preserve the public interface, do not modify the database schema, keep an existing deployment configuration working, or maintain compatibility with current callers.
A larger qualified range gives Cortex more room to keep those requirements beside the technical evidence needed to act on them.
This does not mean every available file should be added to every task. More context is not automatically better context. Irrelevant material can make a problem harder to understand, and missing requirements cannot be repaired by simply increasing input size.
The improvement is more room when the work genuinely requires a larger connected body of evidence.
Long Context That Is Qualified, Not Just Advertised
Large context windows have become a common AI specification. But accepting a long input and working effectively with that input are different claims.
Pervaziv AI evaluated Cortex Code 2.0 across its expanded operating range using coding outcomes rather than treating maximum capacity alone as the milestone.
The long context qualification suite produced a 90.3% aggregate pass rate, with all evaluated ranges meeting release criteria. A separate matched standard task suite produced a 100% pass rate, with zero percentage point regression against its baseline.
Those measurements answer different questions.
The long context result measures whether the coding specialist can continue producing useful results as the connected workload grows. The standard task result checks whether the expanded capability came at the expense of everyday coding quality.
The percentages are not intended to be compared directly, and neither represents a universal success rate for every repository or software task.
Together, they support the release objective: add materially more room for complex engineering without degrading the established experience for ordinary coding work.
Cortex Code 2.0 also passed qualification through the live Cortex product path, connecting model evaluation with the product experience developers actually use.
More Room When Needed, Not on Every Request
Most coding tasks do not need 256K tokens of context.
A developer asking Cortex to explain a function, update a focused test or make a localized change should not have to think about maximum context capacity before starting.
Focused tasks can continue through smaller operating ranges, while larger connected requests can use extended capacity when warranted. Developers provide the relevant material and Cortex applies an appropriate operating range for the task.
That right sized approach also has an operational benefit. Extended context consumes additional inference resources, including memory used to retain active context. Smaller profiles can require less reserved capacity, which can support better concurrency and lower infrastructure cost for routine work.
For customers, the infrastructure detail reduces to a simple experience: routine work remains practical, and complex work gets more room when it needs it.
Where More Context Changes the Work
Cortex Code 2.0 is especially relevant when understanding depends on several sources of evidence remaining connected.
A large feature can keep requirements, interfaces, implementations and tests in view across components. Complex debugging can connect symptoms and logs to callers, shared utilities and configuration. Refactoring can preserve architectural intent across dependent packages. Migrations can keep new requirements beside compatibility constraints. Change review can place proposed edits beside the contracts and validation evidence needed to judge them.
The common thread is not simply more code. It is more of the relevant relationship between pieces of the system.
That is where long context becomes an engineering capability rather than a capacity claim.
More Context Does Not Mean More Authority
Cortex Code 2.0 expands what the coding specialist can consider. It does not expand what it is authorized to control.
Cortex Code can produce software engineering output. Cortex Planner can structure work. Cortex Analysis can investigate evidence. Cortex Verify can independently evaluate results. Routing and decision models can help choose a workflow. Cortex Confidential can provide semantic privacy and egress risk advice inside protected workflows.
Permissions, execution boundaries, deterministic policy and customer configured privacy requirements remain separate from the amount of context available to the coding model.
A broader technical view can improve the basis for a coding decision, but it should not silently grant additional access, tool authority or permission to move sensitive information.
More intelligence remains inside the same control structure.
Predictable Behavior When Capacity Changes
Extended capacity is a specialized service capability and can occasionally be unavailable.
Where a request can be served appropriately through another qualified path, Cortex can continue the work and make that outcome visible. Where it cannot, the product returns a clear failure rather than presenting incomplete work as though the full request had been considered.
For engineering teams, that distinction matters. An explicit interruption can be retried or narrowed. An answer that silently omitted important context can create a much harder problem.
Availability handling also preserves the privacy and permission requirements attached to the workflow.
More of the Codebase. More of the Problem. One Connected View.
Cortex Code 1.0 established the coding foundation inside the Cortex AI Model Ensemble. Cortex Code 2.0 expands how much connected software evidence that specialist can work with and makes that additional capacity practical within the product.
For developers, the release means more room for the relationships that define real engineering work: requirements and implementation, interfaces and consumers, configuration and behavior, migrations and compatibility, changes and tests.
For enterprise teams, it strengthens coding without collapsing the broader system of planning, security, privacy, governance and independent verification around it.
As AI takes on longer and more consequential software work, useful intelligence has to remain connected to the problem without losing the controls that make the result reviewable and dependable.
Cortex Code 2.0 moves that vision forward with approximately twice the qualified context range, measured long context performance, retained everyday coding quality and a right sized operating model built for both focused tasks and complex software change.
More of the codebase can remain in view. More of the engineering problem can stay connected. And the rest of the Cortex Ensemble remains in place to help plan, protect and verify what happens next.
Cortex Code 2.0. More context where it matters. More connected software engineering.
