A note to all readers: We are making this entire analysis free to everyone. Most GenAITech pieces include a paid section, but we think this topic is early enough—and potentially consequential enough across AI infrastructure, software, and the broader technology supply chain—that maximizing distribution matters more than putting this one behind a paywall. If you find the framework useful, please share it with investors, operators, and builders who are thinking about where agentic AI goes next.
Think of an RL environment as a driving school’s closed practice course—but for AI agents. A learner can practice parking, merging, and responding to obstacles, receive an objective score, and repeat the exercise after the course resets—all before entering public roads. Similarly, an AI agent practices real jobs inside a resettable digital workplace, learns from what went wrong, and improves before touching customers or production systems.
RL stands for reinforcement learning. In practical terms, an RL environment combines software, data, tools, permissions, a task, and a verifier. The agent attempts the job, the system checks what actually happened, and the result becomes training data, a regression test, or both.
If this practice loop becomes standard, it could create a large, recurring compute workload. Just as millions of driving lessons require an ongoing supply of vehicles, facilities, fuel, and instructors, millions of AI practice runs require GPUs, CPUs, databases, sandboxes, storage, networking, and power.
This is not a hypothetical architecture—it is already how frontier labs improve agentic systems. OpenAI says Codex was trained with reinforcement learning on real-world coding tasks across varied environments, where it can edit files, execute commands, run tests and iterate until the result passes. OpenAI’s deep-research agent was similarly trained through end-to-end RL on multi-step browsing and reasoning tasks. Anthropic trains Claude inside simulated web environments, rewarding it for resisting malicious instructions, while Google DeepMind’s SIMA 2 practices tasks through trial and error across games and newly generated virtual worlds, then feeds those experiences into subsequent training. The domains differ, but the underlying system is the same: place an agent inside a resettable environment with tools and state, give it tasks, verify or reward what it actually accomplishes, and repeat the loop until its behavior improves.
McKinsey says: we see reinforcement learning delivering this value across the business, with potential applications in every business domain and industry
That is why, The investor question this article answers is straightforward: can this repeated practice loop create enough monetizable demand to help justify roughly $720 billion to $745 billion of 2026 hyperscaler capex—and which companies capture the profit pool?
Across recent anonymized hedge-fund, private-equity, and technology-investor inquiries, the diligence has already moved beyond “which model wins?” Clients are separately investigating agent sandboxes, durable execution, managed inference, RL services, task and verifier suppliers, observability, enterprise action layers, and custom silicon.
Please note: The insights presented in this article are derived from confidential consultations our team has conducted with clients across private equity, hedge funds, startups, and investment banks, facilitated through specialized expert networks. Due to our agreements with these networks, we cannot reveal specific names from these discussions. Therefore, we offer a summarized version of these insights, ensuring valuable content while upholding our confidentiality commitments.
Based on the latest 2026 guidance and management commentary, Microsoft, Amazon, Alphabet, and Meta alone are pointing toward roughly $720 billion to $745 billion of capital expenditure or cash-capex investment this year, although the companies use different definitions and lease treatments. Microsoft now expects approximately $175 billion of calendar-year capex after a lease-classification change; Amazon raised its cash-capex expectation to approximately $220 billion; Alphabet expects $195 billion to $205 billion; and Meta expects $130 billion to $145 billion. Microsoft, Amazon, Alphabet, Meta
Figure 1. Reported guidance and management commentary. Company definitions differ, so the aggregate should be read as an approximate range rather than a harmonized accounting measure.
The bear case is understandable. Amazon’s trailing free cash flow moved to a $7.6 billion outflow, primarily because of higher AI-related property and equipment purchases. Meta generated only $784 million of free cash flow in Q2 after $31.1 billion of capital expenditures. Alphabet explicitly warned that infrastructure investment will pressure depreciation, data-center operating costs, and free cash flow. Amazon, Meta, Alphabet
But the current operating data do not look like an obvious aggregate glut. Azure grew 43% in Microsoft’s latest quarter while demand continued to exceed available capacity. Google Cloud grew 82%, backlog reached $514 billion, and Google said its model APIs were processing approximately 22 billion tokens per minute, up from 16 billion one quarter earlier. AWS grew approximately 37%, while Amazon said both its AI and chips businesses had exceeded $25 billion annualized revenue run rates. Microsoft, Alphabet, Amazon
What clients are trying to answer now
Is the RL-environment layer the missing bridge between AI capex and software ROI—or another expensive layer with no durable return?
This article answers four questions, in the order investors need them answered:
Product: What is an RL environment—and why does it matter to a $720B capex cycle?
Capital allocation: Where does the next $1 of RL-environment spend go?
Profit pool: Who captures the profit pool—and who gets compressed?
ROI: From $1,800 to $64 million per month, when does RL-environment ROI work?
Our answer is directionally bullish for aggregate AI demand—but highly selective for individual assets.
RL environments do not guarantee that every data center earns its cost of capital. They add a credible third demand engine—experience production—that most AI-capex models still underweight.
Pretraining creates general intelligence. Production inference applies it. RL environments repeatedly manufacture the experiences through which agents learn to perform economically useful work.
Production inference will usually remain the most continuous wall-clock workload. RL environments matter because they add a recurring lifecycle loop around it: every model, prompt, tool, workflow, customer configuration, security policy, or production failure can trigger another round of sandbox execution, evaluation, adversarial testing, and post-training.
Figure 2. Analytical framework, not reported company data. Production inference is generally the most continuous wall-clock workload; RL environments add a broader, increasingly recurring lifecycle layer across CPUs, accelerators, databases, sandboxes, storage, networking, orchestration, and verification.
The thesis in four numbers
$720B-$745B: approximate 2026 capex or cash-capex guidance across Microsoft, Amazon, Alphabet, and Meta.
34.1%: the best listed model score on ServiceNow EnterpriseOps-Gym despite 1,150 tasks, 512 tools, and 164 database tables.
3.6B to 32T tokens per month: the illustrative range from a small internal enterprise program to a frontier-lab environment curriculum.
$1.8K to $64M per month: the corresponding illustrative model-execution range before sandbox, storage, verifier, and training overhead.
Methodology and compliance note: this article uses public disclosures, public research, open-source benchmarks, the author’s analytical framework, and anonymized themes from recent institutional primary-research inquiries. No client identity, project detail, employer information, holding, purchase intent, or confidential consultation content is disclosed. Inquiry frequency is not evidence of an investment conclusion; numerical scenarios and company-positioning charts are illustrative, not recommendations.
Q1. What Is an RL Environment—and Why Does It Matter to a $720B Capex Cycle?
The first recurring client question is the most basic: what exactly are companies buying when they say “RL environment”?
The category currently mixes at least four products: isolated agent computers, durable workflow execution, model runtime and post-training, and proprietary task-and-verifier content. A sandbox can run the agent; it does not define the job or prove that the job was completed safely.
Traditional software puts most decision logic in application code. Agentic software moves more of the editable surface into the surrounding environment: the desired outcome, tools, permissions, task distribution, failure conditions, and verifier. The agent chooses the path.
Figure 3. Agentic software moves the primary engineering asset outward—from explicit decision logic to the environment that defines the agent’s world, tasks, tools, constraints, and success conditions. The deterministic foundation remains essential.
Software does not disappear. It becomes the deterministic substrate underneath the agent.
Databases, APIs, transactions, identity, permissions, workflow engines, audit, rollback, and policy controls remain essential. As agent authority moves from draft to read, write, transact, and administer, the economic value of those guarantees rises.
The shift is subtler:
Software moves from directly encoding every decision to defining the world, tools, constraints, and success conditions within which an agent decides.
What is an RL environment—in plain English?
A serious RL environment has three core components: (1) a world with realistic state and tools; (2) a distribution of economically meaningful tasks; and (3) executable verifiers that check final state, safety, scope, cost, policy, and side effects. Execution vendors can host the world and durable-execution vendors can keep it running, but the scarce content is the task distribution and the definition of success.
Figure 4. A serious RL environment is a resettable digital world containing realistic state, economically meaningful tasks, and executable checks of outcomes and side effects. The scarce asset is not merely data volume; it is high-fidelity, resettable, verifiable task infrastructure.
Mercor used essentially this framing when it announced its acquisition of Deeptune, arguing that the constraint in reinforcement learning was shifting toward the environments themselves. Deeptune had recreated hundreds of enterprise applications as practice environments for frontier labs. Mercor
A serious environment is therefore not a static prompt-and-answer dataset. It must be isolated and resettable, support multi-step tool use and durable state, expose realistic failures and permissions, and score what happened in the system—not merely what the agent claimed.
ServiceNow’s open-source EnterpriseOps-Gym makes the complexity concrete. It contains 1,150 expert-curated tasks across eight enterprise domains, 512 tools, and 164 database tables. Tasks execute against live tool servers and are evaluated primarily by SQL verifiers checking the final environment state. The best model listed by the project currently solves only 34.1% of tasks. ServiceNow EnterpriseOps-Gym
Figure 5. ServiceNow’s EnterpriseOps-Gym makes the capability gap tangible: the benchmark is already broad and stateful, yet the best listed model solves only 34.1% of tasks. The displayed score may change as models and the benchmark evolve.
The exact benchmark score will change. The more durable point is that a sandbox is not the environment. Modal, E2B, Daytona, and Runloop provide isolated computers; Temporal, Inngest, and Restate make long-running actions durable; Baseten, Fireworks, and Together run or post-train models; task suppliers create trajectories and verifiers. A production gym stitches those layers together.
This is already visible in coding, security, and physical AI
OpenAI says Codex was trained with RL on real coding tasks and iterates against repositories, commands, linters, and tests. Its harness-engineering work makes the shift explicit: as agents write more code, engineering moves into environments, feedback loops, abstractions, and controls. OpenAI
Security and physical AI show the same architecture: GPT-Red uses attacker-defender self-play; Meta ARE packages rules, tools, content, and verifiers; NVIDIA Isaac Sim and Isaac Lab use physically based simulation, synthetic data, and sim-to-real validation.
The pattern now spans coding, cybersecurity, enterprise and data operations, scientific and professional work, and robotics.
The maturity curve matters more than the hype cycle
Not every workflow needs a sophisticated RL gym today. The transition should be analyzed workflow by workflow.
Figure 6. Agent authority should not outrun environment and verification maturity. The demand inflection for stateful gyms occurs when agents move from recommending actions to executing consequential work.
The critical rule is:
Permitted autonomy should equal the minimum of environment maturity, verifier quality, recoverability, governance, and observability—not the average.
A company with excellent models but no rollback is immature. A company with sophisticated environments but unverifiable business outcomes is also immature.
The demand inflection likely occurs between bounded autonomy and gym-gated development. Once an agent can modify consequential state, each material release needs hidden tasks, repeated stochastic trials, and adversarial scenarios. The buyer’s scorecard shifts toward autonomous resolution, hours saved, integration burden, total cost, and critical-failure rate.
The test suite is no longer merely checking code. It is sampling a policy’s behavior across a distribution of possible worlds.
The scarce asset changes
The most valuable proprietary asset may be a private corpus of realistic state, economic tasks, verifiers, expert trajectories, production failures, adversarial cases, and customer permissions. In financial terms, value migrates from $/seat and $/developer-hour toward $/verified task, $/trajectory, and $/autonomous outcome.
Source code is becoming easier to generate. Reliable evidence that an agent can perform valuable work safely is not.
Q2. Where Does the Next $1 of RL-Environment Spend Go?
Once clients understand the product, the next question is where the next dollar lands.
Recent inquiries are splitting the stack into at least eight diligence markets—from sandboxes and durable execution to task suppliers, observability, enterprise action layers, and custom silicon. Treating all of this as “GPU demand” obscures where revenue, margins, and bottlenecks actually accrue.
A large-scale environment combines model inference, policy optimization, ordinary software execution, databases, browsers, application servers, isolated sandboxes, snapshots, durable workflow state, logs, networks, verifiers, orchestration, and human-authored task content.
Figure 7. The environment becomes a compounding learning asset: curriculum produces episodes; executable verification supports evaluation and post-training; risk-tiered deployment produces new failures and trajectories that expand the next curriculum.
Where the next $1 goes
Those conversations are already vendor-specific. Sandbox buyers compare Modal, E2B, Daytona, and Runloop on cold start, GPU access, snapshots, security, and cost; durable-execution buyers compare Temporal, Inngest, and Restate on retries, idempotency, checkpoints, and human waits; managed-inference buyers compare Baseten, Fireworks, and Together on model mix, RL support, cost per rollout, and gross margin.
Public-company data support the fragmentation. Microsoft reports nearly 40 million registered agents and hundreds of thousands of business actions; Google processes roughly 22 billion model-API tokens per minute; Amazon says its AI and chips businesses each exceed $25 billion annualized revenue. The workload is a service graph, not a single chip.
The key investor takeaway is:
The highest-quality infrastructure exposure is not raw capacity. It is infrastructure that removes a bottleneck from a recurring, monetized agent workload.
The best exposure removes a measurable bottleneck from a recurring, monetized workflow. Raw servers, undifferentiated sandboxes, and powered shells do not automatically qualify.
The runtime may commoditize faster than the environment content
The rise of open-source environment infrastructure—and rapidly expanding hosted environment hubs—is strategically important.
Harbor and Datacurve’s Pier make containerized coding-agent task formats increasingly portable across local Docker and hosted sandboxes.
OpenEnv supplies an open environment API, while NVIDIA NeMo Gym supplies shared resources, verifiers, evaluation, and training abstractions.
Prime Intellect’s Verifiers provides open task and reward abstractions and a distribution path for community environments.
Hosted platforms such as HUD and OpenReward are already packaging environment development, quality control, execution, and distribution.
This is good for adoption and bad for undifferentiated software pricing.
The likely pattern resembles open-source databases and orchestration frameworks:
Generic runtime and task specification increasingly open and portable
Managed scale, security, distribution, and support commercially useful but competitive
Proprietary task distributions, verifiers, domain state, and failure data potentially the highest-value layer
“We spin up containers and collect rewards” is not a durable moat. Pricing power is moving toward fast reset and branching, private networking, credential isolation, durable orchestration, cost attribution, and—most importantly—proprietary environment content.
exclusive workflow, production-failure, and near-miss data;
deep vertical expertise and realistic state generators;
difficult-to-game verifiers and reward governance;
snapshot, restore, branching, and secure hidden-test mechanics;
a trusted benchmark brand and uncontaminated held-out tasks;
a scalable domain-expert network and expert trajectories;
direct evidence that environments improve held-out capability and production outcomes.
Q3. Who Captures the Profit Pool—and Who Gets Compressed?
The next recurring client question is not whether spending grows. It is which companies convert that activity into durable margin rather than merely absorbing more competition and capex.
Our framework starts with eight diligence clusters but only three structurally scarce assets.
Figure 8. Anonymized primary-research inquiry patterns across recent institutional diligence. Company names are research subjects—not evidence that any client owns, plans to buy, or has reached a favorable conclusion on them.
Three assets remain structurally scarce: economical compute/interconnect/power; authoritative workflow state and permissions; and proprietary task distributions, failure data, expert trajectories, and verifiers.
More likely to commoditize are generic runners, undifferentiated sandboxes, static benchmarks, trace-only dashboards, thin interfaces, labor without reusable IP, and capacity with the wrong location or compute mix.
1. Silicon wins—but a $16M-$64M monthly rollout workload changes which silicon captures the marginal dollar
NVIDIA remains the most obvious direct beneficiary because agentic RL requires a large volume of model generation. In the frontier-lab scenario in Q4, 32 trillion rollout tokens per month translate to roughly $16 million to $64 million of monthly model execution before environment overhead. Each episode can involve long reasoning traces, multiple model calls, tool use, verifier inference, and a subsequent policy update.
But the second-order conclusion is more interesting:
The more repetitive and measurable rollout workloads become, the more economically attractive specialized silicon becomes.
A frontier research run may justify maximum programmability and premium GPU economics. A mature environment generating billions of similar trajectories may favor custom accelerators, smaller specialized models, lower precision, disaggregated serving, or heterogeneous CPU/GPU execution. Google’s Ironwood TPU is explicitly positioned for large-scale training, complex reinforcement learning, and high-volume inference—an unusually direct statement of this convergence.
The likely architecture is heterogeneous: GPUs for frontier reasoning; ASICs for stable rollouts; CPUs for simulated worlds and verifiers; infrastructure processors for isolation and I/O.
NVIDIA therefore remains central for frontier and high-variance reasoning, while Google TPU and Broadcom-supported ASIC programs can gain as rollout patterns standardize. TSMC and semiconductor-equipment suppliers collect across architectures; Arista and optical suppliers benefit from parallel east-west traffic; and Micron and other memory suppliers benefit as active state, HBM, DRAM, flash, snapshots, and trajectory persistence expand.
The risk is that efficiency gains or custom silicon redistribute the profit pool faster than total workload grows. The infrastructure thesis can be right while the wrong architecture or valuation still loses.
2. Hyperscalers can monetize one episode across eight or more services—but absorb the depreciation risk
A single episode can generate revenue across model inference, CPU execution, databases, storage, networking, sandbox runtime, identity, observability, security, and post-training. The hyperscaler can therefore monetize far more than the headline token bill.
This is why Microsoft, AWS, Google Cloud, and Oracle can capture more than the headline token bill. They own the surrounding service graph.
The same structure magnifies depreciation, power, financing, and pricing downside when utilization disappoints.
Microsoft, Amazon, and Alphabet have an additional advantage: proprietary models, developer ecosystems, enterprise distribution, and systems of record. Oracle combines cloud infrastructure with databases and business applications.
Meta is different. It can benefit through better models, advertising systems, engagement, and internal productivity, but it does not resell the full cloud service graph at comparable scale. It therefore bears more of the capex while monetizing it indirectly through its own products.
Specialists such as Baseten, Fireworks AI, and Together AI can capture the higher-value managed-inference and post-training layer, while sandbox specialists such as Modal monetize the execution around the model. Their upside is workload focus and faster product velocity; their downside is hyperscaler bundling, pricing pressure, customer concentration, and hardware residual-value exposure.
3. Systems of record can become the largest software winners—if they capture agent actions, not just human seats
The simplistic bear case says agents replace SaaS applications. The more realistic outcome is bifurcation.
Applications contain two sources of value: the human interface, and the underlying state-and-control layer of data, permissions, rules, transactions, and audit.
Agents are deflationary for the first layer and potentially inflationary for the second.
Figure 9. Illustrative positioning. Agents can bypass screens, but safe execution still requires authoritative state, permissions, business semantics, and auditability.
The current ITSM market makes this bifurcation concrete. Recent institutional diligence is comparing Serval, Atomicwork, Console, Ravenna, and Harmony alongside ServiceNow, Jira Service Management, and Freshservice. The question is not only rip-and-replace; it is whether an AI-native action layer captures growing transaction volume while the incumbent retains the governed record.
The buying criteria are revealing: autonomous resolution, human hours saved, total cost, integration depth, governance, and admin burden—not chatbot eloquence. Atomicwork supports deployment atop ServiceNow or Jira; Serval supports two-way sync; Console connects across existing IT systems. The likely transition is an AI action layer over a legacy system of record.
The system of record still owns authoritative state, workflow history, permissions, and audit. The AI layer may own the employee interface, orchestration, and consumption meter. Microsoft’s nearly 40 million registered agents illustrate the potential action volume. ServiceNow, SAP, Salesforce, Workday, Atlassian, Microsoft, and Oracle can win only if they expose agent-accessible actions and monetize that activity.
The emerging private-company risk is that Serval, Atomicwork, Console, Ravenna, Harmony, or a future horizontal agent becomes the preferred action layer while the incumbent is reduced to a governed database. The incumbent advantage is distribution and deeply embedded semantics; the challenger advantage is automation velocity and a product designed around outcomes rather than tickets.
The strategic question is whether the incumbent captures growing agent-action volume or becomes a lower-growth database behind someone else’s interface.
Figure 10. Conceptual framework. The commercial unit can shift from user access toward agent actions and completed outcomes.
4. Observability, identity, and security become a recurring tax on autonomy
An ordinary application usually executes a path engineers specified. An agent can select tools, alter plans, retry, delegate, access new context, and take a different path on every run.
The telemetry object now includes agent/model identity, prompt and memory state, tool sequence, permissions, state changes, cost, verifier result, policy violations, and production outcome.
Recent diligence in regulated sectors suggests governance is becoming a recurring budget line, not a one-time implementation. Datadog and Honeycomb can provide cross-model telemetry and agent-accessible production context; Palo Alto Networks and CyberArk can govern identity and authority. The decisive question is whether the platform records permissions, state changes, verifier results, and rollback—not just traces.
This expands observability from “what did the model say?” to “which agent took which action, using whose authority, against which state, at what cost, with what verified result, and can the action be reversed?” Regulated industries are likely to push this standard first.
Figure 11. As agent authority and blast radius increase—from draft to read, write, transact, and administer—the required control plane strengthens from observability to scoped access, policy enforcement, transactional safety, and system governance.
The risk is bundling. Hyperscalers, model platforms, systems of record, and durable-execution vendors can absorb parts of this stack. The vendors most likely to retain pricing power are those that observe and govern agents across many models, clouds, applications, and execution runtimes.
5. Consulting, BPO, and AI-data services face the largest business-model transition
The same transition that creates the environment market also threatens labor-volume economics.
Traditional consulting and BPO monetize $/hour, $/seat, call-center volume, manual exceptions, and $/label. Agentic systems target precisely those units of revenue.
That knowledge becomes more valuable when converted into task distributions, application replicas, expert trajectories, verifiers, policies, and production-to-training loops.
Accenture is better positioned than a pure labor outsourcer because it can combine transformation, integration, industry knowledge, and managed services. Genpact, TaskUs, TP, Appen, TELUS Digital, Scale AI, and other AI-data providers face a more explicit migration: from headcount and isolated labels toward executable experience, verifier quality, and managed outcomes.
Coding-data diligence now asks how labs source long-horizon tasks, prove quality, and earn attractive unit economics after static labeling. Datacurve describes durable environments, agent trajectories, and domain-sensitive verifiers; Turing, Centific, Mercor/Deeptune, Scale AI, HUD, and Prime Intellect attack adjacent layers.
The winning model moves from $/hour or $/label toward $/task, $/trajectory, and $/verified outcome. The losing model remains dependent on commoditized annotation and routine labor without a production-to-training feedback loop.
6. The exposed unit is usually a business model—not the whole company
The conclusion is neither “all software is dead” nor “every incumbent wins because it has data.” RPA diligence asks the same question: does a UiPath-style product remain a per-bot scripting layer, or evolve into governed orchestration for agents, APIs, approvals, and deterministic side effects?
The real question is whether an incumbent can transform its data, workflows, labor knowledge, customer distribution, and execution controls into agent-addressable state and reusable learning infrastructure.
Q4. From $1,800 to $64M per Month: When Does RL-Environment ROI Work?
The final question clients ask is whether the workload is large enough to matter. Our illustrative scenarios span more than four orders of magnitude: $1,800-$7,200 per month for a small internal enterprise program, $300,000-$1.2 million per month for a vertical agent vendor, and $16 million-$64 million per month for a frontier lab.
What verified economic outcome pays for that recurring spend?
The wrong model is cost per benchmark run. The right model is cost per verified successful economic outcome.
Production inference remains the more continuous wall-clock workload. The environment layer becomes material because the same workflow is rerun across task variants, candidate policies, repeated trials, and release cycles.
The rollout multiplier
Monthly rollout tokens = workflows × task variants per workflow × candidate policies or checkpoints × repeated trials × tokens per episode × evaluation cycles per month
The token model still excludes verifier calls, expert trajectories, adversarial agents, synthetic task generation, policy updates, failed episodes, sandbox/orchestration overhead, and production inference.
Figure 12. The logarithmic scale is the message. A persistent curriculum can move from billions to tens of trillions of rollout tokens depending on the number of workflows, variants, policies, and trials.
Case A — Frontier model lab
Illustrative assumptions
500 environment families
5,000 task states per environment
8 candidate policies or checkpoints
4 trials per task
200,000 tokens per episode
2 complete cycles per month
This produces:
80 million episodes per cycle
16 trillion tokens per cycle
32 trillion tokens per month
At an illustrative effective model-execution cost of $0.50 to $2.00 per million tokens, model execution alone represents approximately $16 million to $64 million per month, before environment runtime, storage, reward models, synthetic generation, or policy updates.
This is not a forecast of any specific lab. It demonstrates why the environment layer becomes material once a lab operates across hundreds of domains and millions of task states.
Case B — Vertical agent vendor
Illustrative assumptions
100 economically important workflows
1,000 hidden variants per workflow
5 candidate agent configurations
3 trials per task
100,000 tokens per episode
4 release cycles per month
This produces approximately:
600 billion rollout tokens per month
$300,000 to $1.2 million of model-execution cost per month at the same illustrative cost range
For a vertical software company, buyers will justify that spend only when it improves measurable operating outcomes:
higher autonomous-resolution or verified task-success rates;
fewer human review hours and lower exception-handling burden;
fewer production incidents, unsafe actions, and policy violations;
lower integration and administrative cost;
lower cost per verified success and better gross margin;
higher retention and expansion into more valuable workflows;
consumption or outcome-based revenue.
The gym is not merely R&D overhead. It can be the mechanism that permits the company to sell a higher level of autonomy.
Case C — Internal enterprise agent
Illustrative assumptions
20 workflows
100 variants per workflow
3 agent configurations
3 trials per task
50,000 tokens per episode
4 cycles per month
This produces approximately:
3.6 billion rollout tokens per month
$1,800 to $7,200 of model-execution cost per month at the same illustrative cost range
That is not enough by itself to justify a hyperscale data-center thesis. It can still be economically attractive if the environments prevent one serious outage, reduce hundreds of labor hours, or enable safe automation of a high-volume process.
This distinction matters:
The data-center demand thesis does not require every enterprise to become a frontier RL lab. It requires thousands of labs, agent vendors, software companies, and enterprises to operate persistent learning and evaluation loops across millions of workflows.
The ROI denominator: verified economic outcomes
Environment ROI = labor avoided + revenue uplift + incidents and rework avoided + faster release value + expansion into higher-autonomy workflows - rollout compute - policy-training compute - environment engineering - expert review - production oversight
The relevant operating metric is not cost per million tokens or even cost per episode.
It is:
Cost per verified successful economic outcome at an acceptable risk level.
The unit varies by workflow: $/accepted pull request, $/fully resolved support case, $/safely remediated vulnerability, $/repaired data incident, or $/audited financial exception.
Figure 13. Illustrative denominator: a $12 million annual environment, evaluation, and rollout program. The economics become compelling only when autonomous outcomes are valuable and recurring at scale.
The matrix prevents an indiscriminate compute-bull argument: 1,000 monthly outcomes worth $50 are nonviable against a $12 million annual program, while 25,000 outcomes worth $500—or 50,000 worth $1,000—can create substantial leverage if the outcomes are incremental and safe.
Why efficiency does not automatically destroy the demand thesis
The strongest bear argument is that models, chips, inference engines, and specialized models will become dramatically more efficient.
They almost certainly will.
Lower cost per episode can expand demand by moving more workflows over the automation threshold, increasing hidden variants and trials, and making longer or more valuable tasks affordable.
This is why diligence on Baseten, Fireworks and Together focuses on multi-sourcing, open-model mix, post-training support, cost per rollout, and gross-margin trajectory. The key question is whether task volume and complexity grow faster than cost per task falls.
Google’s current disclosures illustrate the possibility. Even while reducing the cost of AI responses through model and hardware optimization, API usage continued rising rapidly to approximately 22 billion tokens per minute. Alphabet
The same dynamic can apply to agentic RL: efficiency is bearish for unit cost but potentially bullish for total consumption when it unlocks new demand.
Does this prove the data-center glut thesis wrong?
No.
It makes the aggregate demand case stronger, but the asset-selection problem harder.
There are at least six reasons overbuild can still occur:
Workload- and availability-mix risk. Training and many RL/evaluation jobs can be relatively interruptible; production inference and enterprise action systems require much stricter uptime. A facility designed for one may be poorly matched to the other.
Useful-life and depreciation risk. Accelerators, memory, networking, and cooling designs can age faster than accounting schedules—or before demand arrives at the assumed price.
Geographic, power, and supply-chain risk. Capacity without the right power price, grid connection, network adjacency, memory availability, or customer proximity can remain stranded.
Capability and monetization risk. Agents may improve more slowly than expected on high-value work, or achieve attractive benchmark scores without producing enough safe customer value to pay for the compute.
Backlog, RPO, and pricing risk. Reservations and reported pipeline can reflect real scarcity, but they do not automatically translate into durable high-margin usage; investor diligence is explicitly testing FOMO versus committed demand.
Consolidation and open-source risk. Large labs and hyperscalers may internalize the highest-value environments, while generic sandbox, orchestration, and evaluation frameworks become open or bundled.
The right conclusion is:
RL environments make an aggregate AI-compute glut less inevitable. They do not make every data-center project economically sound.
The likely outcome is polarization: premium capacity with the right compute mix, power, network, software stack, customers, and utilization remains scarce, while poorly located or inflexible capacity can still become oversupplied.
Investor Dashboard: The 10 Metrics That Matter Before Revenue Is Obvious
Clients are already moving beyond chatbot seats toward operating metrics that connect agent activity to spend and verified outcomes.
The most useful dashboard includes registered agents and business actions; sandbox startup, reset, and restore latency; durable workflow completion and replay; cost per rollout; model-provider mix; critical-failure rate; production failures converted into regression tasks; infrastructure mix; availability tier; and utilization. These are closer to the unit economics than user counts alone.
The commercial unit of software is beginning to move from user access toward agent activity, verified task completion, and completed economic outcomes.
That creates a metered relationship between software value and infrastructure consumption that traditional SaaS did not have—and it makes failure, governance, and execution efficiency financially visible.
Figure 14. The thesis strengthens the aggregate AI-demand case while increasing dispersion across infrastructure, software, services, and data-center assets.
Conclusion: The $720B Capex Question
The $720 billion to $745 billion AI-capex debate is being misread if it is framed only as:
More accelerators train larger models, and more chatbot queries monetize them.
The more consequential possibility is that software itself becomes an ongoing learning system—and that every meaningful workflow creates a recurring practice, verification, and improvement workload.
In that world, every important workflow can require a digital environment, realistic task distribution, ground-truth verifier, repeated rollouts, adversarial testing, optimization, production monitoring, and a failure-to-curriculum loop.
The data center is no longer only serving intelligence.
It is manufacturing experience.
That changes the software stack, monetization, and infrastructure demand.
Source code becomes less scarce; environments, tasks, verifiers, permissions, workflow context, and production trajectories become more scarce. Seats acquire consumption meters as agents perform variable work, while demand spreads beyond accelerators into CPUs, networking, databases, memory, storage, sandboxes, durable execution, observability, security, and power.
And it changes the ROI debate.
The scenario range—from roughly $1,800 per month for a small internal program to $64 million per month for a frontier-lab curriculum—shows why aggregate demand can deepen without every enterprise becoming a frontier RL lab.
But the standard for investors should remain demanding.
RL environments will not rescue infrastructure that is too expensive, poorly located, technically inflexible, or disconnected from monetizable agent demand. Nor will environments create ROI when the agent cannot complete valuable work reliably enough to replace or augment human labor.
The most useful formulation is narrower:
Pretraining creates intelligence. Inference monetizes intelligence. RL environments industrialize the production of competence.
If agent competence continues to expand from coding and research into customer service, security, IT, finance, data operations, healthcare, logistics, and physical work, then the addressable compute market is not merely the market for answering questions.
It is the market for learning how to perform work across the economy.
That is a larger and more persistent demand thesis than the market’s current “chatbot revenue versus data-center capex” spreadsheet captures—but it remains a selective trade, not a universal AI beta.
Discussion
The central investor question is where the durable economic rent sits: scarce compute and interconnect, authoritative systems of record, proprietary task and verifier suppliers, cross-system observability and security, or the agent products that turn trained competence into completed work.
Which layer captures the largest share of the next $1—and which public company is the cleanest expression of that view?
Disclosure: This article is informational analysis, not investment advice or a recommendation. Company positioning and scenarios are illustrative. Institutional inquiry patterns are anonymized; company names are research subjects and do not indicate client holdings, purchase intent, or favorable conclusions.
Shareable map: the agent learning stack
A note on what we are building
The more we researched this transition, the more convinced we became that RL environments are not merely a frontier-lab research artifact. They are likely to become part of the development infrastructure for any company deploying agents that take consequential actions.
So we are starting a new company, focused initially on private RL-ready environments for data science and enterprise agents.
The idea is simple: take a workflow an agent cannot afford to get wrong, recreate it in a resettable environment, generate realistic failures and hidden variations, and verify success against actual system state rather than an LLM judging another LLM.
We are opening a small founding-design-partner cohort. If your team is already deploying operational agents and has a workflow that is difficult to evaluate safely before production, we would like to hear about it.
