What Are RL Environments? Who Builds, Buys and Prices Them

Originally published at aidata.broker.

An RL environment is a sandbox in which an AI agent attempts a task, using the tools the sandbox gives it, while a verifier checks the result and turns it into a score that trains the model. Labs buy them by the task and by the environment: builders and lab researchers interviewed by Epoch AI put a task with its grader at $200 to $2,000, a working replica of a website at about $20,000 and a high-fidelity clone of an app like Slack at about $300,000 - Epoch AI. The spending behind them is large: leaders at Anthropic have reportedly discussed spending more than $1 billion on environments in a year, and Scale AI wrote, as Fortune reported, that nearly half of its new data-training projects involve them.

This guide is for three kinds of reader. A holder of code, company records or expert knowledge who keeps hearing that labs "buy environments" and wants to know whether what it holds could become one. A builder of tasks and environments who wants to know who pays and what. And a reporter or investor who wants the plain mechanics behind a market where 89 vendors on our vendor register now say they build or sell environments. It covers what an environment is, how it differs from a dataset, the main types, who builds and buys them, what each costs according to public records, what makes one valuable, how a company's existing assets become environments, and how one is sold.

This guide is research from public sources, not legal, tax or investment advice.

Contents

1. What an RL environment is
2. How an environment differs from a dataset
3. The types of environment
4. Who builds environments
5. Who buys environments
6. What environments cost
7. What makes an environment valuable
8. How a company's assets become environments
9. How to sell an environment
10. Questions people ask
11. What this means for you

What an RL environment is

Reinforcement learning (RL) is a way of training a model by letting it try something, scoring the attempt, and nudging the model toward whatever scored well. For a language model that acts as an agent (software that takes steps on its own: it runs commands, clicks through an app, edits files), the "something" is a piece of work, and the place where the work happens is the environment. Epoch AI, which interviewed builders and lab researchers for the most cited account of the field, describes the loop simply: the model attempts a task, a grader scores the attempt, and the scores update the model's weights - Epoch AI.

An environment has three parts, and each is something a vendor can sell. The sandbox is the world the agent acts in: a copy of a code repository, a working clone of an app, a desktop with files on it, a simulated company with its records. It is defined by the actions the agent can take and by what those actions do, and it is usually shipped as a container (a packaged copy of the software that runs the same way on any machine). The task is an instruction with a goal: "fix the failing checkout test", "file this expense report", "build a pivot table of revenue by region". The verifier (also called a grader) decides whether, or how well, the goal was met. In coding it is usually a set of tests that fail before the fix and pass after it; elsewhere it can be a script that inspects the final state of the app, or a rubric that another model applies.

{
  "url": "https://epoch.ai/assets/images/gradient-updates/2026/state-of-rl-envs/example_rl.png",
  "alt": "Diagram of an RL environment: a task is given to an AI agent, the agent sends actions such as search_channel and send_message to a simulated Slack workspace running in a container, receives observations and error messages back, and a grader converts the final state into a reward",
  "title": "The parts of an RL environment",
  "caption": "Source: Epoch AI, An FAQ on RL environments, January 2026 (CC-BY)"
}

The word that matters most is verifiable. The training method behind most of this market is often called RLVR, reinforcement learning with verifiable rewards, and vendors describe their products in those terms (ARIMLABS builds "RLVR training environments"; Andromede calls itself "an RL data lab generating environments, tasks, and verifiers from real-world data"). A verifiable reward is a score a machine can compute without a person reading every attempt, which is what lets a lab run the same task many times over. The model may attempt one task dozens of times in a single training run, and the verifier has to judge every attempt correctly, cheaply and without being fooled.

Why labs want this now is the other half of the definition. Models learned to write from reading the public internet; they learn to do work by practising it, and there is no public supply of practice. Epoch's interviewees put the shift in one sentence: "Math and coding tasks came first, but we're now seeing significant growth in enterprise workflows: tasks like navigating Salesforce, filing reports, or manipulating spreadsheets." On Hugging Face, the largest free hub for training data, only 148 datasets carry the rl-environment tag. Finished environments are almost absent from the free supply, which is why labs pay for them.

Two terms you will meet. A gym (or "UI gym") is an environment built as a replica of a website or app. An eval is an environment or task set used to measure a model rather than train it: the structure is the same, the licence and the buyer's purpose differ. Epoch notes that the boundary between "environment" and "task" is itself fuzzy, and in practice a lab buys the two together.

How an environment differs from a dataset

A dataset is a fixed collection of examples. A model reads it (pretraining, where it learns language and facts from text) or imitates it (supervised fine-tuning, where it learns to copy good answers). Once a lab has the dataset, it has everything the dataset can teach. An environment is interactive. The model acts, the environment responds, the verifier judges the outcome, and the lab can generate as many fresh attempts as its compute allows. What the lab buys is not a set of answers but a machine for producing graded experience.

That difference changes how each is priced and how long each keeps its value. A dataset is priced by volume (per hour of video, per word, per company archive) and an archive of real human work keeps its value for years, because no model can produce it for itself. An environment is priced per task or per environment, and it loses value as models get better at it: an investor's analysis of the category put an environment's useful life at a half-life of about six months, adding that "the same customer rarely buys the same environment twice". A task that current models always pass teaches nothing, so a builder's product loses value as it works: the better the models it trains, the sooner it is retired.

The two meet in one place. Every attempt an agent makes inside an environment can be recorded as a trajectory (the full sequence of the agent's reasoning, actions and the environment's responses), and a set of trajectories is a dataset again. Together AI generated 258,000 test-verified coding-agent trajectories for a reported $130,000 in compute, about 50 cents each, and released them free. That number marks what a machine-made trajectory is worth. It is the human-built environment, and the real material inside it, that a model cannot produce for itself.

The evaluation column matters for holders because the same task can be sold twice in different ways. Labs and evaluators pay for private, uncontaminated test sets, in one practitioner's words, "because public benchmarks have leaked into pretraining data". Scale AI's SWE-Bench Pro benchmark keeps a commercial set of 18 proprietary repositories bought from early-stage startups for exactly that reason: a model cannot have trained on code it has never seen.

The types of environment

Environments are usually grouped by what the agent is asked to do. Coding came first because a test suite is a ready-made verifier: a task either makes the tests pass or it does not. Website replicas came next, as labs built agents that operate a browser. The growth area now is enterprise work, where an agent operates business software (a CRM, an accounting system, a ticket tracker) inside a simulated company, and professional domains such as finance, law and science, where the grader encodes an expert's judgment.

The table below lists the main types with the builders and buyers recorded for each and the public prices on record. Prices marked as paid to a contributor are what an individual is paid to build a task, not what a lab pays the vendor; the gap between the two is covered under what environments cost.

Coding repositories

The coding environment is the template for the rest. A repository is frozen at the moment before a real change was made; the task is the issue that asked for the change; the verifier is the set of tests that the real change made pass. SWE-bench, the public benchmark built this way from open-source projects, is public, so its tasks and their answers can leak into training data; that is why the market pays for the same structure built on private code. micro1 recruits engineers to "build reproducible Reinforcement Learning Environments that test an AI model's ability to fix code, add features, refactor, and optimize performance", each with a golden reference solution, at $50 to $100 an hour for about 15 hours a task. A codebase that already holds thousands of such changes, each with its ticket and its tests, is raw material for this kind of environment, which is the subject of our companion guide on selling a codebase to AI companies.

Website and app replicas

A replica is a working copy of a website or SaaS product, filled with plausible data, in which an agent can click, type and submit without touching the real service. Simple ones are cheap, and the market is crowded with them: one lab researcher told Epoch that "what everyone does is vibe code a buggy website which isn't useful". High-fidelity clones of complex products cost an order of magnitude more, at about $300,000 for a Slack-grade copy. Turing pays contributors $300 per approved task for Python backend replicas of tools such as Slack, Linear, Jira, Notion and Gmail.

The replica price has a consequence for any company that owns an interface. Where a lab can have a clone of a site built for about $20,000, it does not need the company that runs the site. The cost of a replica caps what an interface alone is worth. What a replica cannot copy cheaply is what fills it: realistic records, real workflows, and the judgment that decides whether a task was done well.

Enterprise work and professional domains

Enterprise environments put an agent inside a simulated company: a CRM with accounts in it, an inbox with threads, a ticket queue, a finance system with a month to close. The tasks are the ordinary work of that company, and the grader checks the end state or applies a professional's rubric. This is where real company data enters the picture. Halluminate, which builds finance and consulting environments, told Fortune that one set's "88 tasks were based on anonymized private-equity transactions", and Ooak says it "turns anonymized real company data into datasets and RL environments". The section on how a company's assets become environments follows that thread.

Who builds environments

Builders fall into four groups, and the lines between them are blurring. The first is specialised startups that do nothing else: Mechanize for coding agents, Halluminate for finance and knowledge work, Deeptune for software "training gyms", Collinear, Plato, Vibrant Labs and dozens more. Of the 150 AI data vendors on our register, 89 say on their own pages that they build or sell RL environments, gyms or graded tasks.

The second group is the established data vendors that added environments to human data work: Scale AI, Surge AI, Mercor, Turing, Handshake AI, Labelbox, Snorkel AI, Invisible Technologies and Toloka. Their advantage, as Epoch's interviewees put it, is that they can staff a project with experts quickly. Mercor's chief executive described the economics on a Sequoia podcast: a task that takes "ten hours of human time" paid at $150 an hour has a cost basis of about $1,500, and Mercor's tasks run "from $50 to $10,000" (both his own figures). Mercor also bought Deeptune, an environment builder that had raised a $43 million Series A earlier the same year, at an undisclosed price.

The third group is platforms and open hubs. Prime Intellect runs an Environments Hub and paid bounties to anyone who built an open environment, crowdsourcing more than 400 environments and evals in two months and committing "hundreds of thousands of $ in grants". HUD provides a platform and open-source software for building environments and running agents in them, and a marketplace, DataVendor, where independent builders list task sets and environments; HUD raised a $16M Series A and says vendors on that marketplace are "already doing millions a month" (its own claim).

The fourth group is the labs themselves. Epoch reports substantially more in-house building at labs and neolabs, and SemiAnalysis reports that Anthropic's own engineers have made coding tasks for over a year while it also buys from startups (SemiAnalysis, reported). Product companies are a natural fifth partner when the environment is their own software: Epoch names Benchling working with Anthropic, and Shopify and Stripe working with OpenAI.

What building one costs in people

Most of the cost of an environment is skilled time. TechCrunch reported in 2025 that Mechanize was offering software engineers $500,000 salaries to build environments, and SemiAnalysis reported that Mechanize expects engineers paid $400k+ a year to make one good task a week. In September 2026 Google closed a reported talent-and-licence deal worth about $1.5 billion or more for Mechanize. The contributors who write individual tasks are paid far less than the labs pay for them: across public prices, makers are paid a median of $300 per task, while buyers pay 9.5 times what makers are paid, per task. Per-task pay looks scattered, but it lines up once a platform's own time estimate is applied: coding tasks converge on about $45 to $100 an hour of work.

Who buys environments

Environments are bought mainly by frontier labs, the handful of companies training the largest models, and Epoch's interviewees describe training as the main use, with requests for benchmarks much less common. The largest buyers are known mostly through reporting rather than disclosure. Anthropic's leadership reportedly discussed spending more than $1 billion on environments over a year (The Information, via TechCrunch), and SemiAnalysis calls Anthropic "the most aggressive lab by far" in buying coding data from environment startups. SemiAnalysis also reports that OpenAI bought hundreds of website replicas for ChatGPT Agent. Halluminate says four of the top five closed-source US labs are paying customers and that it reached a mid-eight-figure revenue run rate (its own figures).

Below the frontier labs sit neolabs (newer, well-funded model companies) and companies training their own agents. A neolab researcher told Epoch of contracts in the $300K to $500K range, often per quarter. Scale of purchase varies as much as price: Mercor's chief executive said "certain frontier labs might buy 50,000 tasks a month from us", a vendor's description of its own business rather than a disclosed contract.

Governments and evaluators buy environments to test models rather than train them. The UK AI Security Institute awarded a cyber-range contract of £999,600 for realistic enterprise networks with tasks, solvers and automated graders; the EU AI Office awarded an agentic evaluation interface contract of EUR 968,521 over two years. METR, an evaluation non-profit, pays a bounty of $300 per hour it would take a professional to complete the task, one sign of how evaluators anchor a task's price on the human time it takes.

Where buyers meet builders matters for anyone with something to sell. Most labs buy through vendors and marketplaces rather than from individual builders. HUD's DataVendor lists task sets and environments for lab research teams and says requests are "usually priced per task, at around $500 to $1,500 a task, with hundreds to thousands of tasks per request". On 12 October 2026 a lab buyer chose five lots in one round through a buyer-side referral network, two of them environment lots: an engineering set of 12K+ containerised tasks graded automatically, and a science research environment scored on rubrics (both reported, with no price given). Our lot index currently lists 63 lots of datasets and environments on public catalogues.

What environments cost

Environment prices come in three units and from three sides of the market, and mixing them up is the commonest mistake in reading this market. The units are per task, per environment and per contract. The sides are what the buyer pays the vendor, what the vendor pays the person who writes the task, and what it costs to produce. A contributor's $50 a task and a lab's $5,000+ a task are both true; they are different sides of the same trade.

The table collects the public prices on record. The Epoch figures come from interviews with people who build and buy environments, so they are reported practice rather than a price list, but they are the anchors everyone in the field quotes.

{
  "title": "What one RL task sells for, by source",
  "subtitle": "Low and high end of each published per-task range, in US dollars (buyer side, 2025 to 2026)",
  "type": "grouped-bar",
  "xKey": "source",
  "yKeys": [{"key": "low", "label": "Low end ($/task)"}, {"key": "high", "label": "High end ($/task)"}],
  "data": [
    {"source": "Epoch AI interviews", "low": 200, "high": 2000},
    {"source": "HUD DataVendor requests", "low": 500, "high": 1500},
    {"source": "Mercor, legal at scale", "low": 2000, "high": 2000},
    {"source": "SemiAnalysis, coding", "low": 5000, "high": 5000},
    {"source": "Mercor, full range", "low": 50, "high": 10000}
  ],
  "yAxisFormatter": "currency",
  "source": "Epoch AI, HUD DataVendor, Sequoia (Mercor), SemiAnalysis; each row linked on the AIData.Broker price board",
  "sourceUrl": "/prices"
}

Sources: Epoch AI interviews, HUD DataVendor requests, Mercor, legal at scale, SemiAnalysis, coding, Mercor, full range.

Why a task costs what it costs

Two anchors explain the band. The first is the human time a task takes to write and verify: an expert's ten hours at a professional rate is the cost basis Mercor describes, and evaluators such as METR price private tasks by the professional hours needed to solve them. The second is the compute a lab will spend training on the task. Mechanize, then an environment builder, argued that a frontier lab spends about $2,400 in compute over a task's life, so it is "inefficient for AI labs to spend significantly less than ~$500 per RL task": a cheap, flawed task wastes compute worth several times its price. Mercor's chief executive described a single post-training run of an open model on 1,800 tasks using about $500K in compute. When compute per task runs that high, a buyer has every reason to pay for tasks that are right.

Aggregated, the public prices give medians you can sanity-check an offer against. Made-to-order work in this category has a median of $2,837 per task, $42.7K per environment and $722K per contract across the published prices, while the median cost to produce a task is $1,500. Each figure links to its derivation and the prices behind it on the rates page.

What moves the price

Exclusivity is the largest single multiplier on record. Two environment founders independently told Epoch that "exclusive deals are roughly 4-5x more expensive than non-exclusive ones". That multiple is a price, not a default, and it ends every other sale of the same environment. Form of payment matters too: Prime Intellect's bounty sheet paid twice the bounty when taken as GPU credits, a sign that a lab with spare compute values its credits at about half their face value. Delivery terms are priced separately by some builders: Robotics Center ships custom environments as a private repository licensed for perpetual internal use and negotiates redistribution rights on top.

What makes an environment valuable

The people who buy environments are consistent about what they pay for, and the list is short. The first item is a sound verifier. One interviewee told Epoch: "Soundness matters most: high reward must mean the task was actually solved, not hacked" - Epoch AI. Reward hacking is the term for a model finding a way to score well without doing the work: deleting the failing test instead of fixing the code, printing the expected output, exploiting a gap in the checker. A model trained on a hackable environment learns the hack. Robust graders take many rounds of adversarial testing, which is a large part of why good tasks cost what they cost.

The second item is calibrated difficulty. A task every current model passes teaches nothing; a task no model ever passes gives no signal to learn from. Buyers want tasks that current models pass sometimes, and a spread of difficulty across a set, so the model has a gradient to climb. That is also why an environment's value decays: as models improve, tasks drift from "sometimes" to "always" and get retired. Builders who record how current models perform on each task (pass rates) can show a buyer where the set sits.

The third is realism. An environment that behaves like the real software, filled with records that look like a real company's, teaches skills that transfer to real work; a quickly built replica teaches the replica. Epoch's interviewee was blunt about the low end ("vibe code a buggy website which isn't useful"), and the most valuable enterprise environments are built from real material, such as Halluminate's tasks based on anonymized private-equity transactions.

The fourth is no contamination. A task that has appeared anywhere public (a benchmark paper, a GitHub repository, a blog post) may already be in a model's training data, and a model that has seen the answer is not learning. Labs pay for private, uncontaminated sets, and evaluators write it into their terms: METR requires a task it buys to stay off the public web. For holders this is the most important point in the guide. Material that has never been public is the scarce input, and publishing it, even partly, removes most of its value.

The fifth is domain expertise that is hard to replicate. Scale AI's data partnership page asks for "Specialized expertise that makes your data hard to replicate." Epoch's interviewees noted that "math tasks are easy to create but don't transfer as well to other capabilities", which is why the market has moved toward finance, law, engineering, science and enterprise work, where the grader encodes a professional's judgment.

Rights inside an environment

An environment is only as licensable as everything inside it. Tasks written by contractors need a written assignment to whoever sells them. Records used to populate a simulated company need the same clearance as any company data sale, including de-identification of personal information. Tasks built from someone else's proprietary material carry that material's restrictions: the Third Circuit's ruling in Thomson Reuters v. ROSS Intelligence held that training material written from a competitor's legal headnotes was not fair use. Our rights hub and the guide to training data provenance cover how to document that chain.

How a company's assets become environments

Most holders will never build an environment, and they do not need to. What they hold is the material an environment is built from, and the market is increasingly paying for that material directly. The clearest case is a codebase. Each reviewed change in a repository's history, joined to the ticket that asked for it and the tests that prove it, is a ready-made coding task: the ticket is the prompt, the merged change is the reference solution, the tests are the verifier, and the repository frozen at the moment before the change is the sandbox. Scale AI built the commercial half of SWE-Bench Pro this way, from 18 startups' repositories it bought, in its own words, "where we contacted the company and purchased their engineering repos".

That is why code buyers price by the task a repository yields rather than by its size. Turing pays $1,000 per qualifying pull request, capped at $10K for a modern codebase. AfterQuery pays contributors $300 per private codebase they connect and $75 per approved task built from it. Mercor pays $130 per approved task built on production Python repositories. The source code page keeps the current prices, and our codebase guide explains the gates that decide whether a repository can be sold at all.

Company records become enterprise environments in the same way. A simulated company needs a CRM full of plausible accounts, an inbox of threads, a ticket queue with real-looking problems, and a record of how the work was actually done, so the grader knows what "done well" looks like. Vendors now build environments from exactly that: Ooak from anonymised company data, DARE Labs with a "data refinery that turns operational data into training datasets, RL environments and evals", The General Data Company from industrial companies' operational records, and Theta Lab by rebuilding hard cases from production agent runs. The buyers of company records say the same: Turing's Project Lazarus asks for "Source code, reviews, tickets, and the iteration history behind what shipped."

Expert knowledge is the third route. A lawyer, accountant or engineer who can write a hard task and a rubric that grades it is building the most expensive part of an environment, which is why per-task pay for professional work sits in the hundreds and low thousands of dollars. That work is commissioned to a buyer's brief and belongs to the buyer under the contract; our expert work page covers it.

Worked example: a software company's records as environment material

Example. Take a 60-person fintech software company, operating for eight years, with its code on GitHub, its tickets in Jira and its tests running in CI. Its engineers have merged changes for years, most of them reviewed, many of them naming a Jira ticket. The company is not going to build environments, but here is what an environment buyer sees.

The code history is a source of coding tasks. Every merged change that names a closed ticket and touches both code and tests is a candidate task; changes that a bot made, that an AI assistant wrote, or that have no tests drop out. At Turing's published terms a modern codebase reaches the $10K cap after ten qualifying pull requests, so for this company the question is less how many tasks it holds than which buyer prices the set best. A buyer that wants a commercial benchmark may want the repository exclusively; exclusive deals run roughly 4 to 5 times a non-exclusive one, and end every other sale.

The tickets, documents and support history are a second source. A finance-workflow environment needs realistic records of how a fintech handles a reconciliation break or a failed payment, and this company holds eight years of them. Those records are sold as company data, valued per company rather than per task, and they need de-identification before any buyer sees them. Our guide on how much company data is worth covers that valuation, and the software companies page lists what buyers ask software companies for.

What the company should not do is publish any of it, post sample tasks online, or let a buyer take the repository before terms are signed. The material is valuable because no model has seen it. The readiness check lists what to prepare first.

How to sell an environment

Builders with finished environments or task sets have four routes to a buyer, and each trades price against effort and control. The first is a marketplace. HUD's DataVendor lists codebases, task sets and environments for lab teams, keeps 20% of earnings when they are withdrawn, and does not tell the builder who bought, bid or took a sample. An environment there is sold with the task set that runs on it, not on its own. The second is bounties and grants, such as Prime Intellect's, which pay a fixed amount for an environment that is then released openly: useful for reputation, but the environment stops being private.

The third route is working through a large vendor, as a contributor paid per task or per hour on one of its projects. The pay is steady (see the cost table) but the work is made to the vendor's brief and belongs to its customer. The fourth is selling directly to labs, through contracts that, by Epoch's account, run six to seven figures per quarter for established vendors. Direct sales pay the most and take the most: relationships with research teams, security reviews, and the capacity to deliver every quarter.

Whatever the route, the preparation is the same:

1. Package it to run without you. A container that builds cleanly, documentation a lab engineer can follow, and a verifier that runs as delivered. Buyers test before they pay.
2. Calibrate it against current models. Record how current models do on each task, retire the ones they always pass, and show the spread. This is the evidence that the set is worth training on now.
3. Keep it private. Show a buyer a description, statistics and a small held-out sample under a confidentiality agreement, never the whole set before terms are signed.
4. Build the rights file. Assignments from every contributor, licences for any source material, de-identification records for any company data inside, and confirmation that no task was derived from a public benchmark.
5. Choose the licence deliberately. Non-exclusive, exclusive (priced as a multiple, for a defined field and period), or evaluation-only. Read the grant: some buyers' terms take a perpetual licence with the right to sublicense through multiple tiers, which is a resale right priced as one fee.
6. Sell while it is current. With a half-life of about six months, a set that waits a year to find a buyer has lost much of its value.

To put a number on a task set before talking to anyone, the valuation prices it from the 36 public prices per task on record, adjusted by how answers are checked, whether each task runs as an environment and whether any was published. A finished environment is valued at $20,000 to $300,000, the reported range from a website replica to a Slack-grade clone. The page for builders of task sets and environments collects what buyers in this segment say they pay for, and the datasets and environments page keeps the current anchors. For how environments sit beside the other kinds of data labs are asking for now, see what AI labs are buying.

Questions people ask

What is an RL environment in simple terms?
It is a practice space for an AI agent: a copy of some software or a simulated workplace, a task to do in it, and an automatic checker that says whether the task was done. Labs run their models through such environments many times and train on the scores. Epoch AI's FAQ is the most complete public description.

What is the difference between an RL environment and a benchmark?
The structure is often identical: tasks plus a way to grade them. A benchmark is used to measure models and is usually published; a training environment is used to improve a model and is kept private. A published benchmark ends up in training data, which is why labs buy private, uncontaminated sets.

How much does an RL environment cost?
Reported prices run $200 to $2,000 per task, with especially complex software tasks reaching $20K. A website replica costs about $20,000 and a Slack-grade clone about $300,000; supply contracts run $300K to $500K and up, often per quarter. Exclusive deals cost roughly 4 to 5 times more.

Who buys RL environments?
Mainly frontier labs, through vendors: Anthropic is reported as the most aggressive buyer of coding environments, and OpenAI as having bought hundreds of website replicas. Neolabs, governments testing models, and companies training their own agents buy too. Most purchases go through vendors such as Mercor, Scale, Turing and Surge, or marketplaces such as HUD's DataVendor.

What is a UI gym?
A UI gym is a working replica of a website or app, filled with plausible data, in which an agent practises clicking, typing and submitting. SemiAnalysis reported they often cost about $20,000 per website. They are now crowded: many vendors build them, and quickly built ones are poor.

What is reward hacking?
It is a model scoring well on a task without doing the work, by exploiting a flaw in the grader: deleting a failing test, hard-coding an expected output, or gaming a rubric. A model trained on a hackable environment learns the trick instead of the skill, which is why buyers rank a sound verifier above everything else - Epoch AI.

Can a company's codebase become an RL environment?
Yes, and it is the commonest way company assets enter this market. Each reviewed change with its ticket and tests is a coding task, which is why buyers such as Turing price code per pull request. The code must be private, owned by the company and free of credentials; our codebase guide covers the checks.

How long does an RL environment stay valuable?
Not long. One investor's analysis puts an environment's half-life at about six months, because models learn to pass it and the same buyer rarely buys it twice. Archives of real company material keep their value far longer than the environments built from them.

What this means for you

If you hold code or company records, you do not need to build anything to take part in this market. Your material is what environment builders and labs are short of, and its value depends on staying private, being clearly yours, and keeping its links (a change joined to its ticket and tests). Start with the readiness check, value a codebase with the valuation or a whole company's records with the records valuation, and read the software companies page for what buyers ask of a company like yours.

If you build tasks or environments, the market rewards sound verifiers, calibrated difficulty, realism and real expertise, and it punishes anything published or easily replicated. Price exclusivity as a multiple, read every licence grant for resale rights, and sell while the set is current. The task set valuation and the offer check help you test a number before you accept it.

If you watch the market, follow the price board, the buyer board and the vendor register; each figure in this guide links to its source there. The wider context is in our guides to AI training data prices, how AI companies get training data and the companies that sell it.

AIData.Broker acts as the holder's agent: the holder itself licenses or sells its data to the buyer, and we do not take ownership of it. Only the holder pays us, a fee fixed in the mandate, only if a sale closes; the pricing page has the terms, and the selling guide explains how a sale runs.