Next-Generation Foundation Models Are Moving Toward Closed-Loop Self-Improvement
The next phase of foundation model development is shifting from parameter-count competition to closed-loop capability growth. This article explains how post-training, agent execution environments, automated evaluation, and experience-driven data generation can help models improve through real task execution, with coding agents as the most practical starting point. It also examines the meaning of “100% RSI,” the engineering challenges of handling hundreds of terabytes of trajectory data, and the safeguards needed to verify that a model is genuinely becoming more capable.
1. From Parameter Scaling to Closed-Loop Training
Discussions about next-generation foundation models are no longer focused solely on parameter counts. Industry reports indicate that some leading model teams are exploring larger architectures while shifting more of their research focus toward post-training, agent execution environments, and model self-improvement.
Compared with simply increasing the number of parameters, this approach places greater emphasis on whether a model can continuously identify problems in real-world tasks, correct its strategies, and convert execution experience into training data for the next iteration.
It is important to distinguish between research objectives and validated product capabilities. Claims involving extremely large parameter counts, hundreds of terabytes of data, or “100% RSI” are better understood as development directions or internal targets rather than publicly verified capabilities that have already been delivered.
From a technology evolution perspective, the next generation of models is likely to advance along three main paths:
- Continued pre-training scale: More high-quality text, code, structured data, and multimodal data can improve general knowledge and representation capabilities.
- Higher-quality post-training: Supervised fine-tuning, preference optimization, reinforcement learning, and automated evaluation can make models more effective at complex tasks.
- Closed-loop agent systems: Models can call tools, execute tasks, record their processes, analyze failures, and feed valuable experience back into training.
The third path deserves particular attention because it changes the traditional one-way workflow of “train once, then deploy.” It gives models a degree of self-optimization through repeated interaction with task environments.
2. Why Post-Training Is Becoming the Next Priority
Traditional training pipelines generally separate model development from real-world application. After pre-training, a model is refined with human-labeled and fixed datasets before being deployed in products or services. This can improve response quality, but it has two major limitations:
- Training data may differ significantly from real-world tasks.
- Human annotation rarely covers long-running workflows, complex tool use, or error recovery.
For example, a model may perform well on a single-turn code generation task but struggle with a long-running engineering problem. It may misunderstand requirements, modify too many files, or fail to identify the cause of a broken test. Simply adding more conventional question-and-answer data is often insufficient. The system needs a task environment that more closely resembles an actual development workflow.
As a result, post-training is shifting from “learning standard answers” to “learning how to complete tasks.” A complete task environment typically includes:
- A clearly defined objective;
- Operable files, databases, or computing resources;
- Executable tool interfaces;
- Automated tests and result validation;
- Execution trajectory logging;
- Constraints on time, resources, and error counts;
- A reproducible scoring mechanism.
The model is no longer asked only to generate text. It must plan steps, call tools, observe feedback, revise its approach, and continue until the task satisfies verifiable completion criteria.
3. Coding Agents Are a Practical Testbed for Self-Improvement
Coding is a suitable starting point for agent self-improvement because it offers relatively strong verifiability.
In open-ended question answering, response quality often requires human judgment. In software development, however, solutions can be evaluated through compilation, tests, static analysis, runtime results, and resource consumption. This allows a training system to distinguish more accurately between an approach that merely appears reasonable and one that actually works.
A closed-loop process for a coding agent can be summarized as follows:
Task input↓Requirement analysis and plan generation↓Code modification or tool invocation↓Test execution and feedback collection↓Error diagnosis and strategy revision↓Result evaluation↓Trajectory filtering and training data generation
The most valuable data is not necessarily the final successful code. It can also include:
- Which step caused the task to fail;
- Whether the model misunderstood the requirements;
- Which actions created unnecessary repeated work;
- Which tool calls produced no useful result;
- When the model should have stopped trying;
- What differed between successful and unsuccessful approaches.
If the system can analyze these signals automatically, a single task execution can be converted into multiple types of training samples. For example, failure causes can become error-diagnosis examples, efficient execution paths can become planning examples, and differences between successful and unsuccessful attempts can become preference-comparison data.
This approach to data generation is closer to real software development than collecting static code alone. It can also better support improvements in long-horizon task performance.
4. How to Understand “100% RSI”
RSI can generally be understood as recursive self-improvement: a model or agent helps generate the experience, data, evaluation results, or even execution framework needed for the next training cycle.
“100% RSI” is better interpreted as a goal of highly automated closed-loop improvement. It does not simply mean that models will completely replace human researchers and engineers.
A relatively complete self-improvement system contains at least four components.
1. Task Generator
The system must continuously propose challenging and verifiable tasks. Tasks should not be too simple, or they will only repeat already learned patterns. At the same time, they cannot be impossible to evaluate, because the system would have no reliable way to determine whether an improvement occurred.
A task generator can use historical failures, capability boundaries, and real business workflows to produce new tasks dynamically. For example, if the model performs poorly on exception handling, the system can generate more tasks involving edge conditions, dependency conflicts, and multi-stage validation.
2. Execution and Observation Module
The agent must execute tasks in a controlled environment and record complete trajectories, including reasoning steps, tool operations, environmental feedback, error messages, and final results.
To make the resulting data useful for training, the execution environment should also support isolation, rollback, and resource limits.
3. Evaluation and Attribution Module
Evaluation should not consider only whether a task succeeded. It should also analyze why the task succeeded or failed. A task may eventually be completed, but if it requires excessive retries, consumes too many resources, or succeeds only because of accidental conditions, it should not automatically be treated as a high-quality sample.
Possible evaluation metrics include:
- Task completion rate;
- Test pass rate;
- Average number of execution steps;
- Error recovery capability;
- Tool-call effectiveness;
- Resource consumption;
- Result stability;
- Generalization to unseen tasks.
4. Data Filtering and Training Module
Not every execution trajectory belongs in the training set. Low-quality trajectories can reinforce poor strategies and may even cause capability degradation.
Trajectories should therefore be filtered according to reliability, difficulty, information gain, and redundancy. The system should also maintain data versioning and quality tracking.
Only when all four components work together can agent execution be reliably converted into improvements in model capability.
5. Extending from Coding to Complex Domains Such as Healthcare
Coding environments provide clear feedback, making them suitable for early validation. However, extending the same approach to high-risk fields such as healthcare and finance introduces substantially higher requirements.
For a healthcare agent, task outcomes cannot be judged solely by text similarity. Evaluation must also consider evidence, risk classification, contraindications, and decision explainability. Generated content must not be treated as fact without verification, and unreviewed automated conclusions must not be inserted directly into real clinical workflows.
In these fields, closed-loop training should incorporate:
- Professional knowledge bases and traceable evidence;
- Multiple levels of review;
- Uncertainty estimation;
- Interception of high-risk operations;
- A combination of expert feedback and automated evaluation;
- Strict data de-identification and access control.
Moving from coding agents to healthcare agents is therefore not a matter of copying the same training pipeline. Evaluation standards, data governance practices, and safety boundaries all need to be redesigned.
6. Engineering Challenges of Hundreds of Terabytes of Data
If a training system continuously generates task trajectories, tool-call records, test results, and failure analyses, its data volume can quickly grow from a conventional dataset to hundreds of terabytes. At that scale, the challenge is not limited to storage capacity. Data quality, retrieval efficiency, and training value become equally important.
Data Layering
Raw execution logs, cleaned trajectories, structured evaluation results, and final training samples should not be stored together. A layered strategy can be used:
- Raw layer: Preserve complete execution records for auditing and traceability;
- Cleaning layer: Remove invalid, duplicate, and sensitive content;
- Feature layer: Extract error types, task difficulty, and tool-use patterns;
- Training layer: Retain high-value samples that have passed quality filtering.
Deduplication
Large numbers of agent trajectories may look different on the surface while representing essentially the same behavior. Without semantic deduplication, training resources will be consumed by repeated samples, and the model may overfit to a narrow set of fixed workflows.
Data Security
Trajectories involving code, business documents, and professional data may contain credentials, personal information, internal configurations, or sensitive business logic. Before entering the training pipeline, data must undergo de-identification, access control, and lifecycle management.
At the infrastructure level, teams will typically need to combine object storage, distributed computing, message queues, container platforms, logging services, and monitoring and alerting systems. Together, these components form a pipeline from task generation to training consumption.
7. How to Determine Whether a Model Is Actually Improving
The greatest challenge in self-improvement is not whether a system can generate more data. It is whether the generated data genuinely produces better capabilities.
If evaluation sets are too similar to training tasks, the model may simply memorize patterns. If only single-task success rates are considered, rising costs and declining stability may be overlooked. A multidimensional evaluation system is therefore necessary.
1. Aligning Small-Scale Experiments with Large-Scale Results
During early training, teams can use smaller models, fewer data samples, and limited compute to test an approach. They can then examine whether the conclusions remain valid at larger scales.
The goal is not for every metric to be identical. The key question is whether the trends remain stable. For example, does the benefit continue as more data is added? Does a particular training strategy remain effective as the system scales?
2. Testing Outside the Training Set
Evaluation tasks must differ sufficiently from training data in terms of task descriptions, code structures, tool combinations, and error types. Continued performance on unseen tasks is stronger evidence that the model has acquired transferable capabilities.
3. Evaluating Cost and Benefit Together
A model that achieves a higher success rate by taking many more execution steps is not necessarily becoming more capable. Evaluation should also track compute cost, response latency, number of tool calls, and the rate of human intervention.
4. Preventing Reward or Evaluator Hacking
When a model learns to optimize the evaluation rules instead of solving the underlying problem, the system may exhibit evaluator gaming. To reduce this risk, evaluation should combine multiple independent metrics and regularly introduce human spot checks, hidden tasks, and dynamic tests.
8. Practical Implementation Recommendations
Teams planning to build an agent training loop can proceed in the following order:
- Start with tasks whose results can be verified automatically;
- Build an isolated, rollback-capable execution environment;
- Record complete task trajectories and resource consumption;
- Structure failure causes instead of saving only final answers;
- Use small-scale experiments to validate the value of data and strategies;
- Create version, source, and quality labels for training data;
- Introduce independent evaluation sets and human spot checks;
- Expand gradually into high-risk industries only after the system is stable.
Overall, competition among next-generation models is shifting from “who has the largest model” to “who can build the most efficient and reliable system for growing capability.”
Post-training, agent environments, automated data generation, and large-scale correctness validation are the core pillars of this system.
“100% RSI” represents an ambitious long-term direction in which models not only complete tasks, but also analyze task execution, improve their strategies, generate high-value training experience, and demonstrate measurable progress under rigorous evaluation.
Fully automated self-improvement remains subject to major engineering and safety challenges. However, building a verifiable closed loop around coding agents is already one of the most practical starting points for exploring this direction.
