Codex in 2035: Scenarios for Software Teams, Verification, and Machine-Written Code

The decisive variable is not how much code agents can emit, but whether organizations can specify, verify, trace, and authorize machine-produced changes at comparable speed.

Abstract

A forecast about Codex in 2035 cannot responsibly extrapolate a product name or benchmark curve. It must distinguish measured productivity and capability evidence, vendor-reported claims, systems analysis, and conditional predictions. This article establishes an August 2026 baseline, then uses two variables--agent capability and institutional verification capacity--to construct four scenarios: instrumented abundance, a verification crisis, bounded automation, and fragmented stagnation. It examines how software-team tasks, review queues, formal methods, provenance, supply-chain attestations, and human authority may change as code generation becomes cheaper. Six predictions specify horizons, assumptions, observable indicators, and disconfirmation conditions. The central forecast is conditional: machine-written code can become routine where intent is executable and evidence is cheap, while high-consequence and weakly specified work remains constrained by verification and accountability.

Forecast the system category, not the product label

Nine years is long enough for the name “Codex” to disappear, broaden, or denote a stack unlike the 2026 product. The useful forecast object is therefore a Codex-class software agent: a model-mediated system that observes repositories, edits files, runs tools, receives environmental feedback, and returns evidence for a person or institution to accept.

A forecast about that category must keep four epistemic labels separate.

Measured facts are estimates tied to a study population, task distribution, tool version, and date.
Vendor claims describe reported products, internal use, or demonstrations and may be informative without being independent estimates.
Analysis derives consequences from mechanisms such as queues, verification cost, and authority.
Predictions state future outcomes and must be capable of failing.

The scenarios below are not predictions. They expose combinations of variables. The final section makes six predictions with explicit horizons, assumptions, indicators, and disconfirmation conditions.

The August 2026 evidence baseline

Measured facts: productivity is heterogeneous

Three experiments resist a universal productivity coefficient. A controlled GitHub Copilot study found its treatment group completed one JavaScript HTTP-server task 55.8% faster ^[7]. A randomized trial with 96 Google engineers estimated about 21% less time on a complex enterprise task, with a wide confidence interval and a warning against transferring the estimate across ecosystems and time ^[6]. An RCT with 16 experienced maintainers completing 246 tasks in repositories they knew well found early-2025 tools increased completion time by 19%, although participants believed the tools had accelerated them ^[5].

These results are not a vote to average. They estimate different treatments on different workers and work. By 2035, productivity will still depend on task decomposability, repository maturity, feedback quality, user skill, model, harness, and quality threshold. DORA’s 2025 synthesis similarly describes AI as an amplifier of an organization’s existing strengths and weaknesses and places enabling capabilities around the tool rather than inside it ^{[8, 9]}.

Measured facts: horizon has expanded under bounded evaluation

METR’s time-horizon study defines a 50%-task-completion horizon as the human time associated with tasks an AI system completes with 50% probability. Its 2026 revision reports approximately seven-month doubling in the studied historical series and stresses uncertain external validity ^[4]. Extrapolating that exponent unchanged to 2035 would be numerically dramatic and epistemically weak: benchmark composition, inference budgets, saturation, and real organizational dependencies can all break it.

SWE-bench and SWE-agent establish two narrower facts. Repository-level execution is a more demanding object than isolated code completion, and the agent-computer interface can materially alter performance ^{[10, 11]}. Neither result measures autonomous operation across an arbitrary company’s backlog.

Vendor claims: products already target orchestration

OpenAI’s 2025 Codex launch described isolated cloud tasks lasting roughly 1 to 30 minutes, test execution, terminal evidence, and parallel delegation ^[1]. Its 2026 app announcement reported more than one million recent users, multi-agent worktrees, scheduled automations, skills, and a demonstration consuming millions of tokens ^[2]. OpenAI later reported strong benchmark results and multi-day game-building demonstrations for GPT-5.3-Codex ^[3].

Those are dated vendor reports, not random samples of production projects. They establish product direction and technical possibility. They do not estimate defect escape, organizational return, or the fraction of a backlog safely delegable in 2035.

The two variables that define the scenario space

Let capability for task class $i$ be $C_i$ : the probability that an agent can produce a candidate satisfying a meaningful external evaluator under an affordable budget. Let verification capacity be $V_i$ : the organization’s ability to specify relevant properties, run discriminating checks, preserve provenance, contain actions, and assign accountable authority.

A schematic automation potential is

A_i=C_i\,E_i\,V_i\,G_i,

where $E_i$ captures environment and workflow integration and $G_i$ captures governance permission. A high-capability agent with weak verification does not yield high safe automation. A modest agent can automate a narrow task whose output is exhaustively checked.

The variables can diverge because generating a candidate and proving it acceptable are different computations. If candidate patches arrive at rate $\lambda$ while the organization verifies and integrates them at rate $\mu$ , a simplified review queue is stable only when

\rho=\frac{\lambda}{\mu}<1.

Parallel agents raise $\lambda$ . Better tests, automated analysis, proof, risk routing, and reviewer interfaces raise $\mu$ . Lowering model latency alone can make the system slower by overloading its acceptance stage.

One seed pan crowded with over-dense seedlings beside a long receding row of empty terracotta pans on a glasshouse bench, a single seedling just set into the first empty pan with its roots still uncovered — **Figure 1.** Generation and acceptance are different rates; a change queue stays stable only while verification keeps pace, and parallel agents raise arrivals without raising the rate at which candidates can be checked and absorbed.Image prompt and art direction by Brecht Corbeel; image generated to that direction.

Scenario 1: instrumented abundance

Condition: capability and verification capacity both become high.

Repositories expose machine-readable contracts, deterministic environments, ownership boundaries, and risk tiers. Agents generate implementations, tests, migrations, documentation, and review findings. Independent evaluators reject most weak candidates before human attention. Accepted changes carry provenance connecting task, base state, model/harness configuration, permissions, commands, checks, and authorizing principal.

Teams do not inspect every generated token. They inspect claims and evidence at the appropriate abstraction. Low-risk changes flow through policy; architectural and high-consequence changes receive deeper review. Software supply can expand substantially because acceptance capacity expands with generation.

This is not a world without defects. It is a world where machine generation is integrated into ordinary secure development. NIST’s SSDF already organizes preparation, protection, production, and vulnerability response as lifecycle practices, while its AI community profile shows how the framework can be extended for AI-specific development risks ^{[13, 14]}. SLSA defines source/build provenance and verification attestations; SPDX standardizes software component information ^{[15, 16]}. None currently proves that an agent’s change matches human intent, but they are substrates on which richer evidence can be built.

Scenario 2: the verification crisis

Condition: capability grows faster than verification capacity.

Agents make plausible changes cheaply, and organizations reward visible throughput. Pull-request volume, generated tests, dependencies, and services increase faster than review, integration testing, and operational understanding. Agent reviewers process agent authors, but correlated assumptions survive because generation and evaluation share models, context, or incentives.

The queue is hidden by permissive merging rather than resolved. Latent defects accumulate in interfaces and rarely exercised paths. Security risk rises because tool-using agents process untrusted data; AgentDojo demonstrates that useful task performance and prompt-injection resistance are separate evaluation dimensions ^[12]. A serious supply-chain or infrastructure incident could then produce abrupt restrictions, liability, or local-only deployment.

A wooden riddle of identical mesh tilted over a seed pan with already-sieved compost falling straight through it and nothing held back, a thin flat splinter caught slipping through the mesh edge-on — **Figure 2.** A check that shares the mesh of the thing it checks cannot catch what passed the first time; agent reviewers evaluating agent authors preserve the assumptions both of them already hold.Image prompt and art direction by Brecht Corbeel; image generated to that direction.

The failure is institutional, not simply a hallucination rate. Even a highly capable generator can overload a weak change-control system.

Scenario 3: bounded rigorous automation

Condition: verification becomes strong while general capability plateaus or remains costly.

Organizations automate where specifications are executable: dependency updates with compatibility suites, schema-preserving migrations, generated clients, data transformations, infrastructure changes against policy, and repairs with strong regression tests. Agents remain assistants on ambiguous product work and novel architecture.

Formal methods expand selectively because machine assistance can reduce the cost of writing invariants and proof scripts. CompCert demonstrates the deeper principle: a machine-checked semantic-preservation proof can connect source-level properties to executable compilation ^[17]. But formal proof establishes a theorem relative to a formal statement and trusted base; it does not prove that the statement represents a customer’s need.

This scenario can yield high economic value without general autonomous engineering. Narrow reliability may matter more than impressive open-ended demos.

Scenario 4: fragmented stagnation

Condition: both effective capability and verification adoption advance slowly in substantial sectors.

Frontier firms with clean repositories and compute use agents extensively, while regulated, resource-constrained, legacy, or physically coupled organizations cannot reproduce the gains. Model access, data boundaries, old build systems, liability, and scarce platform expertise create a two-speed software economy.

Some teams retain autocomplete-scale assistance; others orchestrate agent fleets. Global averages become less meaningful because the treatment is not one technology. It is a bundle of infrastructure and organizational complements. The DORA amplifier interpretation predicts this divergence more naturally than a universal replacement story ^[8].

The four scenarios can coexist by repository and task. One bank may run instrumented abundance for internal documentation, bounded automation for payments code, and fragmented stagnation around a mainframe subsystem.

What “machine-written code” should mean

Authorship becomes difficult to infer from the final diff. A person may specify a change, an agent may produce a patch, a second agent may revise it, a developer may edit two lines, and an automated formatter may rewrite the file. Counting characters by last editor produces a weak metric.

A more useful provenance record attaches roles to transformations:

P(\Delta)=\{(r_j,a_j,m_j,h_j,s_j,e_j)\}_{j=1}^{n},

where each event records role $r$ , actor $a$ , model $m$ , harness $h$ , input state $s$ , and evidence $e$ . “Machine-originated” can then mean that an agent produced the first substantive implementation; “machine-verified” can mean automated evaluators generated the acceptance evidence; neither removes the human or institution that authorized deployment.

A single seedling in a terracotta pan being enclosed by the six glass panes of a small cloche folding up on brass hinges, with the last pane still hinged outward — **Figure 3.** Machine-written is an origin claim; acceptance depends on an evidence envelope that connects intent, behavior, provenance, and accountable authority.Image prompt and art direction by Brecht Corbeel; image generated to that direction.

Tests remain essential and incomplete. Static analysis checks modeled properties; tests sample behavior; formal verification proves specified properties; provenance identifies process; runtime monitoring observes deployment; human review judges intent and consequence. No layer substitutes for all others.

Software teams as task-allocation systems

Forecasting jobs directly from code generation confuses occupations with tasks. Acemoglu and Restrepo distinguish displacement of existing labor tasks from reinstatement through new tasks ^[18]. For software teams, agents may displace some translation from specification to code while increasing demand for specification, evaluation, integration, security, platform engineering, incident response, and product judgment.

The likely scarce skill is not “prompting” in isolation. It is building an environment in which an uncertain policy receives informative feedback and limited authority. Senior engineers may supervise more implementation throughput. Entry paths are less certain: routine work can be automated, but organizations still need ways to develop system understanding and judgment. Deliberate apprenticeship, simulation, review, and ownership rotation may replace accidental learning through boilerplate.

Sieved compost pouring down a wooden riddle from one seed pan into the next, one level dropped and hollowed, the other heaped and still rising, a stream still in the air — **Figure 4.** Task automation can reduce direct implementation effort while increasing the value of specification, evaluation, integration, security, and exception work.Image prompt and art direction by Brecht Corbeel; image generated to that direction.

Team size need not fall in proportion to per-task productivity. Lower software cost can increase demand, product variety, maintenance surface, and attempted projects. Whether employment expands or contracts depends on demand elasticity, new task creation, firm entry, and where verification remains labor-intensive.

Six falsifiable predictions

Prediction 1: agent provenance enters mainstream delivery metadata

Horizon: By the end of 2030.

Prediction: At least two major hosted forge or CI ecosystems will expose a signed, queryable provenance record for agent-involved changes that includes more than commit author: model or service identity, base revision, execution environment, checks, and approving principal.

Assumptions: Agent-authored change volume grows; incident investigation and procurement create demand; SLSA/SPDX-style attestations remain extensible.

Indicators: Public schemas, signed attestations attached to pull requests or builds, enterprise retention controls, and policy rules based on agent provenance.

Disconfirmation: No two major ecosystems expose such records by 2030, or available records identify only a generic “AI-assisted” flag without reconstructable process evidence.

Prediction 2: verification capacity becomes the binding investment

Horizon: 2030-2032.

Prediction: High-adoption software organizations will increase spending on automated evaluation, test infrastructure, repository environments, security policy, and review tooling faster than spending on raw code-generation seats or inference.

Assumptions: Candidate generation becomes cheaper and more parallel; demand for software does not collapse; defect and compliance costs remain material.

Indicators: Budgets and hiring shift toward developer infrastructure and evaluation; agent platforms compete on evidence and policy; review queues and escaped-defect rates become explicit AI adoption metrics.

Disconfirmation: Representative high-adoption organizations scale accepted agent-originated change for three years without increasing verification capacity or suffering higher rework, security, or incident cost.

Prediction 3: team roles shift more than occupations vanish

Horizon: By the end of 2032.

Prediction: In high-adoption teams, time-use studies will show a material decline in direct first-draft implementation and a rise in specification, evaluation design, integration, architecture, security, and exception handling, while the software-engineer occupation remains substantial.

Assumptions: New software demand and new tasks offset part of displacement; organizations redesign workflows; agents remain imperfect on ambiguous and high-consequence work.

Indicators: Repeated time-use surveys, job descriptions, training curricula, and promotion rubrics track evaluation and orchestration work rather than code volume.

Disconfirmation: By 2032, measured task shares in high-adoption teams remain statistically similar to 2026, or software-engineer employment collapses without a compensating family of technical specification, evaluation, and integration roles.

Prediction 4: machine-originated code dominates bounded change classes

Horizon: By the end of 2035.

Prediction: In audited high-maturity organizations, at least one consequential but bounded production change class–for example routine dependency remediation or schema-preserving migration–will have more than half of accepted changes machine-originated and machine-prechecked, with humans setting policy and handling exceptions.

Assumptions: Provenance is measurable; task classes have strong evaluators; inference remains affordable; organizations can bound permissions and rollback.

Indicators: Audited origin records, noninferior escaped-defect rates, stable rollback rates, and documented human exception gates for a declared change class.

Disconfirmation: No audited high-maturity organization can show a bounded production class above 50% by 2035, or apparent automation loses its advantage after review, rework, and incident costs are included.

Prediction 5: proof-carrying changes grow, but remain selective

Horizon: By the end of 2035.

Prediction: Machine-assisted formal specifications and proofs will become routine in some high-assurance components, protocol implementations, compilers, cryptographic libraries, and policy engines, but will not become the default acceptance mechanism for ordinary application code.

Assumptions: Agents reduce proof-authoring cost; proof kernels remain small and trusted; organizations can formalize valuable properties; ordinary product intent remains partly tacit.

Indicators: Proof artifacts appear in production pull requests, CI verifies them independently, proof-oriented roles and libraries grow, and assurance cases cite machine-checked properties.

Disconfirmation: Formal-method use remains at roughly its 2026 niche share despite capable agents, or more than half of ordinary application changes require machine-checked proofs as their primary acceptance mechanism.

Prediction 6: high-consequence deployment retains accountable human authority

Horizon: Through 2035.

Prediction: Regulated and safety-critical organizations will use agents for generation and evaluation but retain a named human or legally accountable institutional principal for high-consequence production transitions.

Assumptions: Liability and legitimacy cannot be assigned to a model; correlated model/evaluator failures persist; high-consequence errors remain costly.

Indicators: Segregation-of-duty controls, explicit approval records, agent permission boundaries, and regulations or contracts assigning responsibility to organizations and people.

Disconfirmation: Multiple regulated sectors routinely permit agents to authorize and execute high-consequence production changes without a responsible human or institutional approval, while independently demonstrating noninferior safety and accepted legal accountability.

The central uncertainty is institutional learning

Model capability may advance quickly, plateau, or become commoditized. The more durable question is whether software institutions learn to convert generation into justified acceptance. Repositories with executable intent, reproducible environments, independent checks, provenance, bounded authority, and measured field outcomes can absorb stronger agents. Repositories without them can turn cheap code into expensive uncertainty.

The most defensible 2035 forecast is therefore conditional rather than cinematic. Where verification is cheap and authority is bounded, machine-originated code can become ordinary. Where intent is tacit, consequence is high, and evidence is expensive, humans remain inside the acceptance and accountability loop even if agents write most of the visible text.