The Self-Improvement Path for Next-Generation AI Agents: From Post-Training to Scalable Correctness

    Next-generation foundation models may gain their competitive advantage not only from parameter count or pretraining scale, but from their ability to execute real-world tasks, learn from failures, refine strategies, and feed those experiences back into future training. This article examines a development path built around post-training reinforcement, richer task environments, agentic feedback loops, multi-model experience aggregation, automated data generation, and scalable validation. It also explains why coding environments are a practical starting point, why high-constraint domains require stronger safeguards, and why reliable measurement is essential for any claim of self-improvement.

    Recent public research notes and technical discussions point to an important shift in the development of large models. The core advantage of next-generation systems may no longer depend primarily on parameter count or the size of the pretraining corpus. Instead, it may depend on whether a model can repeatedly experiment in real tasks, summarize experience, correct its strategies, and use those experiences to improve future versions of itself.

    From a technical perspective, this direction can be described as a combination of post-training reinforcement, expanded task environments, agentic feedback loops, and scalable validation. Discussions around “100% RSI” are particularly notable. In this context, RSI can be understood as recursive self-improvement: a model or agent participates in data generation, task execution, error analysis, and training-process optimization, ultimately contributing to the next improvement cycle.

    It is important to clarify that “100% RSI” is better understood as a long-term research objective than as a fully achieved engineering result.

    1. Model Upgrades Are Moving from Parameter Expansion to Systematic Post-Training

    Traditional large-model development generally includes pretraining, supervised fine-tuning, and alignment training. Pretraining establishes broad knowledge and general capabilities, while post-training focuses on reasoning, programming, tool use, task planning, and complex interaction.

    Even when the underlying architecture and parameter scale remain relatively stable, post-training can significantly change a model’s performance. This is because post-training optimizes not only knowledge coverage, but also the model’s decision-making process during task execution.

    For example, a model may already possess the knowledge needed to answer a question but still fail because it does not decompose the task, verify intermediate results, or call the appropriate tool. Reinforcement learning, task feedback, and process supervision can gradually improve these behaviors.

    A relatively complete post-training workflow typically includes:

    1. Designing an executable task environment;
    2. Allowing the model to pursue goals within that environment;
    3. Recording the model’s action trajectories and intermediate states;
    4. Scoring outcomes according to results, cost, and safety constraints;
    5. Selecting high-quality trajectories and representative failure cases;
    6. Using the resulting data for supervised training or reinforcement learning;
    7. Validating whether capabilities have genuinely improved on new task sets.

    This means that model training is gradually shifting from “input a question and produce an answer” toward “complete a task, receive feedback, and continuously revise the approach.”

    2. Aggregating Post-Training Results from Multiple Models May Define a New Development Paradigm

    Some public signals point to a strategy in which several internal models undergo post-training independently, after which their results are aggregated into a next-generation foundation model. This is not simply model merging. It is closer to a development process based on capability specialization, experience aggregation, and unified distillation.

    Different models can take on specialized roles in different environments. For example:

    • One model can focus on long-horizon reasoning;
    • Another can specialize in code generation and debugging;
    • A third can handle tool use and workflow planning;
    • Another can work on highly constrained tasks such as financial calculations and data analysis;
    • A separate model can identify errors and evaluate trajectory quality.

    After independent training, the high-quality trajectories, strategies, and error analyses produced by these models can be organized into training samples for improving the next foundation model. This approach reduces the burden on a single model to explore every type of task and makes it possible to use different reward functions for different environments.

    However, it also introduces significant challenges. Experiences collected from different environments may have inconsistent goals and evaluation standards. Combining them directly can introduce noise. Programming tasks tend to emphasize executability, while financial tasks place greater weight on numerical accuracy, compliance with constraints, and risk control. Without a unified data protocol and quality hierarchy, a model may learn superficial operating patterns rather than strategies that genuinely transfer across tasks.

    Experience aggregation therefore requires at least three mechanisms:

    • Trajectory standardization: Use a consistent format to record inputs, actions, tool outputs, error messages, and final states;
    • Quality grading: Distinguish successful trajectories, partially successful trajectories, invalid attempts, and dangerous behaviors;
    • Capability attribution: Determine whether a successful outcome came from reasoning, effective tool use, or accidental correctness.

    3. Coding Environments Are a Priority Test Bed for Agent Self-Improvement

    Programming tasks are well suited to research on agent self-improvement because they provide relatively clear feedback mechanisms. Whether code runs, tests pass, performance declines, or resource usage exceeds a limit can often be verified automatically.

    Compared with open-ended question answering, coding environments offer more explicit reward signals. An agent can operate through the following loop:

    1. Understand the requirements
    2. ↓
    3. Create an implementation plan
    4. ↓
    5. Generate or modify code
    6. ↓
    7. Run tests and static checks
    8. ↓
    9. Analyze error logs
    10. ↓
    11. Fix issues and validate again
    12. ↓
    13. Submit the final result and process records

    The agent can go beyond modifying application code and improve its own execution framework. For example, it can analyze which tool calls fail most often, which steps cause repeated execution, and which context information is not being used effectively. It can then adjust task decomposition, prompt templates, retry strategies, or verification procedures.

    However, boundaries are essential when an agent modifies its own system. All changes should be tested in an isolated environment, with version tracking, rollback mechanisms, and access controls. For tasks involving production systems, sensitive data, or high-risk operations, model self-evaluation alone is insufficient. Human review and independent verification should also be included.

    4. Expanding from Programming Tasks to High-Constraint Environments Such as Finance

    Applying self-improvement mechanisms to finance, healthcare, industrial control, or other high-constraint domains is considerably more difficult. In these areas, an answer that appears reasonable is not necessarily usable.

    Consider a quantitative finance task. An agent may need to clean data, calculate indicators, backtest a strategy, and analyze risk. Evaluation cannot focus only on final returns. It must also consider:

    • Whether the data contains look-ahead bias;
    • Whether training and test sets are strictly separated;
    • Whether transaction costs and slippage are included;
    • Whether the strategy is overfitted to specific samples;
    • Whether maximum drawdown and volatility remain within reasonable ranges;
    • Whether results remain stable across different market conditions.

    These environments can force agents to learn more rigorous planning and verification procedures. At the same time, the system must prevent a model from exploiting evaluation loopholes to obtain artificially high scores. A robust environment should hide some test conditions, use multi-stage validation, and audit data sources, execution logs, and result calculations.

    5. When Agents Generate Training Data, Quality Matters More Than Volume

    Allowing coding agents to generate their own training data is an important part of the self-improvement path. In theory, an agent can identify weaknesses from execution records and generate new tasks, counterexamples, repair samples, and test cases. This can reduce dependence on manual annotation.

    Automatically generated data, however, is not automatically high quality. Common problems include:

    1. Samples are too similar, leaving the training set with limited diversity;
    2. The model repeatedly generates simple tasks it already handles well;
    3. Incorrect answers are mistakenly labeled as correct;
    4. Generated test cases fail to cover real-world scenarios;
    5. The model learns to optimize the scoring rules instead of improving its actual capabilities.

    A data-generation system therefore needs a generate, verify, filter, and review process. The generator proposes tasks and answers, the executor runs tests, the evaluator analyzes quality, and an independent verifier checks whether the scoring is reliable. High-value samples should also be subject to human spot checks.

    Data quality can be measured across multiple dimensions, including task difficulty, coverage, error types, diversity of solution paths, appropriateness of tool use, and cross-task transfer. New data has genuine training value only when it helps the model solve problems it previously could not solve.

    6. The Real Challenge Is Determining Whether the Model Has Improved

    One of the most easily overlooked problems in a self-improvement system is how the model can confirm that it has actually become better.

    If evaluation metrics are unreliable, the model may simply learn to fit the test set. If the reward function is too simple, the system may obtain high scores through shortcuts. If training and evaluation data overlap, the apparent capability improvement may have little practical meaning.

    This is why the concept of scalable correctness is important. It requires continuously testing whether conclusions observed in small-scale experiments remain valid as training scale, data volume, and compute budgets increase.

    Key questions include:

    • Do trends observed at small training scales continue at larger scales?
    • Does an increase in reward also improve real task success rates?
    • When one metric improves, do cost, stability, or safety deteriorate?
    • Does the model generalize to tasks it has not seen before?
    • Are conclusions stable across random seeds and different data splits?

    In engineering practice, teams can plot the relationship between training scale and capability metrics, compare gains across configurations, and record the real contribution of every change. Important conclusions should ideally be validated with independent evaluation sets, adversarial testing, and human review.

    7. From Model Self-Optimization to Self-Optimizing Research Systems

    Self-improvement is not merely about having a model generate more answers. It means enabling the model to participate in more parts of the development process, including:

    • Designing task environments;
    • Generating training samples;
    • Writing and maintaining evaluation programs;
    • Analyzing failure trajectories;
    • Optimizing tool-calling workflows;
    • Adjusting the agent execution framework;
    • Proposing new experiments;
    • Comparing the effects of different training strategies.

    During the foreseeable next phase, humans will still need to define objectives, establish risk boundaries, design evaluation systems, and make final decisions. Models can expand the exploration space and reduce repetitive work, but they cannot automatically prove that the objective itself is reasonable. Nor can they replace human judgment concerning safety, compliance, and social impact.

    A more realistic technical path is to build a layered feedback loop:

    1. Task definition layer: Specify objectives, constraints, and risks
    2. Environment execution layer: Provide an interactive and verifiable task space
    3. Agent decision layer: Plan, call tools, and complete tasks
    4. Evaluation and feedback layer: Calculate results, cost, stability, and safety metrics
    5. Data production layer: Preserve high-quality trajectories and failure cases
    6. Training update layer: Apply supervised learning, reinforcement learning, or distillation
    7. Independent audit layer: Check for data leakage and metric gaming

    Only when these layers work together reliably can continuous model iteration avoid becoming a simple self-reinforcing loop.

    Overall, exploration around very large data targets and “100% RSI” reflects a broader change in AI development. Training may no longer end when a model is released, and models may no longer be passive recipients of data. Instead, they are gradually becoming participants in task execution, experience summarization, and engineering optimization.

    The long-term ceiling of these systems may depend less on a single parameter metric and more on the quality of task environments, the reliability of feedback mechanisms, the efficiency of data loops, and the ability to validate results at scale. For developers and enterprises, building observable, reversible, and measurable agent infrastructure may be more important than simply pursuing larger models.