The Next Scaling Law for AI Agents Isn’t Data. It’s Environments.

Consider how a coding agent works. You ask it to fix a bug. It opens several files, searches the repository, modifies a function, runs a test, receives an error, changes another file, runs the test again, and eventually produces a working solution. All of these steps can be saved as a trajectory. That trajectory is useful. A future model can study how another agent approached the problem. It can learn which files were opened, what commands were executed and which solution eventually worked.

But the trajectory is frozen. It is essentially a recording of one agent solving one problem in one particular way. The underlying software repository is much more valuable. Give that repository to another agent and you can ask an entirely different question. You can introduce another bug. You can change the requirements. You can ask the model to optimize performance rather than repair functionality. You can let a stronger future model attempt the original task again.

Most importantly, the agent can actually execute its actions and observe whether they worked. That means the environment is not just another piece of training data. It is a generator of training experiences. This distinction may become increasingly important as AI moves from language models toward agents.

During pretraining, one document generally represents one static sample of human-generated information. During agent training, one executable environment can potentially generate hundreds or thousands of different interactions. 

The economics of data begin to change.

Terminal-Universe starts from an interesting observation: even when the original coding environment has disappeared, an agent trajectory often contains enough evidence to partially reconstruct it. Every time an agent reads, edits, creates or deletes a file, it leaves information about the workspace behind. The researchers use those traces to reverse the process.

Recorded file operations are replayed to restore files toward the state they were in before the original agent modified them. This creates a partial reconstruction of the workspace. A separate completion agent then attempts to supply missing files and dependencies needed to make the environment usable again. The result is not simply a reconstruction of the original answer. It is an executable workspace.

Once that workspace exists, the researchers can recover the original task, but they can also generate completely new tasks inside the same environment. The system can extend tasks across related repositories or turn a single request into a multi-round interaction in which requirements evolve over time.

Applied to publicly available terminal-agent trajectories, the researchers report producing roughly 37,300 task-sufficient environments. Training Qwen3.5-27B on data derived from these reconstructed environments improved performance on Terminal-Bench 2.1 by 11.9 percentage points, while multi-round performance on EvoCode-Bench v2 MT@4 improved by 13.8 points. 

The benchmark gains are notable. But the more important idea is the mechanism behind them. 

Terminal-Universe effectively turns:

one trajectory → one reusable environment → many possible tasks → many new trajectories

That is a fundamentally different scaling structure from collecting more demonstrations.

The internet gave language models an extraordinary training set because humans had already spent decades producing text. There is no equivalent internet of agent environments.

GitHub contains enormous amounts of code, but a repository alone is not necessarily a clean agent-training environment. Dependencies may be missing. Services may no longer exist. Tests may be broken. The state required for a particular task may be unknown. There may be no reliable way to determine whether the agent actually completed the requested objective.

Agents need something closer to a simulator. The environment must have state. Actions must change that state. The system must return observations. Ideally, the result should also be automatically verifiable. Coding happens to be one of the best places to build this infrastructure because software already contains many of these properties.

• A compiler can tell you whether code compiles.

• A unit test can determine whether a function behaves correctly.

• A terminal can execute commands.

• A repository provides structured state.

• A benchmark can reset the environment and allow another attempt.

In other words, software development naturally provides something AI researchers desperately need for agent training: ground truth generated by interaction. This is one reason coding agents may be progressing so quickly. Coding is not simply a lucrative application for AI. It is also one of the rare domains where the world itself can provide cheap, machine-readable feedback.

Once environments become reusable, another possibility appears. Imagine an executable repository that initially contains ten meaningful tasks. A sufficiently capable model could explore the codebase and discover new bugs, optimization opportunities, architectural problems and feature requests. Another model could generate realistic user requirements. A verifier could test proposed solutions.

Suddenly the environment is producing its own curriculum. Instead of humans manually creating every training example, the system begins generating new experiences from the structure of the environment itself. This starts to resemble reinforcement learning more than conventional supervised learning. The valuable object is no longer the answer.

It is the system that can continually produce new questions, actions and consequences. The distinction is subtle but important. A dataset is consumed. An environment can be explored. And if an environment can be explored repeatedly by increasingly capable models, its value may actually increase as the models improve. A trajectory produced by today's coding agent may become obsolete when tomorrow's agent is dramatically better. The underlying environment does not.

Tomorrow's model can simply enter it again and discover a better solution.

If this direction continues, the infrastructure behind frontier agents could eventually resemble a stack with several distinct scaling layers. At the bottom are the environments themselves: software repositories, browsers, operating systems, enterprise applications, games, simulations and eventually robotic or physical environments. Above them sit verifiers that determine whether actions succeeded. Then come task generators capable of continuously producing new objectives with different levels of difficulty. Above that are the trajectories generated when agents interact with those tasks. And finally, those experiences feed back into training.

The loop becomes:

Environment → Task → Agent → Action → Feedback → Verification → Training → Better Agent

Then the better agent is sent back into the environment. This matters because the loop potentially creates something that static datasets cannot provide: continually increasing difficulty. A model trained on a fixed collection of demonstrations can eventually exhaust the useful information in that collection. A sufficiently rich environment does not have the same limitation.

As the agent improves, we can ask it harder questions.

Coding is probably only the beginning. A browser environment could train agents to navigate complicated websites, compare information, fill forms and recover from unexpected interface changes. A simulated company could train agents to manage inventory, respond to customers, negotiate schedules and coordinate with other agents.

Games already provide extremely rich environments where goals, rules and feedback can be generated at enormous scale. Robotics pushes the concept further. A physics simulator can expose an embodied model to millions of variations of objects, lighting conditions, failures and physical interactions long before the system touches a real robot. The common pattern is the same.

The closer AI gets to taking actions rather than producing answers, the more valuable interactive environments become. Language models learned from records of what humans had already done. Agents may increasingly learn by doing things themselves.

There are important reasons to be cautious. A reconstructed environment may contain errors. A generated task may not reflect real human needs. Automated verifiers can reward technically correct but practically useless behavior. An agent trained extensively inside synthetic environments may become exceptionally good at exploiting the assumptions of those environments rather than handling the messy reality outside them.

This is the same problem reinforcement learning has encountered repeatedly: optimizing a measurable reward is easier than specifying what we actually want. Environment diversity matters too. Training an agent on millions of tasks generated from a narrow family of code repositories might produce impressive benchmark gains without creating a broadly capable software engineer. The difficult part of environment scaling may therefore not be producing more tasks inside the same world. 

It may be producing more kinds of worlds. Terminal-Universe itself points in this direction by expanding both the breadth and depth of reconstructed tasks, including interactions that span related workspaces and multi-round sessions that simulate evolving user requirements.

For years, AI companies competed over datasets.

Who had the largest corpus?

Who had the best proprietary data?

Who could acquire more human feedback?

Agentic AI could create another form of competition. The strategic asset may become collections of high-quality, executable environments with realistic state, reliable verifiers and enormous task diversity. A company with ten million static coding demonstrations has ten million examples. A company with one million rich coding environments may have something much more powerful: the infrastructure to create an effectively unlimited number of new experiences.

And coding is only one domain.

Imagine the same logic applied to cybersecurity labs, scientific software, financial systems, logistics networks, browser workflows, digital twins and robotic simulation. The companies building the most capable agents may eventually be distinguished not only by the models they train, but by the universes those models are allowed to inhabit during training. That is why Terminal-Universe is interesting.

It is not merely a technique for recovering coding repositories from old agent logs. It hints at a larger transition in AI.

The scaling era of language models was built on turning the world's information into tokens.

The scaling era of agents may be built on turning the world's systems into environments.