100T-Level Data and 100% RSI: Decoding the Next-Generation AI Agent Training Route
Recent developments in large model research indicate a shift from simply expanding parameter sizes to building comprehensive self-improving agent systems. This article analyzes the technical trends behind 100T-level data targets and 100% RSI (Recursive Self-Improvement), exploring how systematic scaling, closed-loop feedback, and task-specific environments will shape the next phase of AI agent development and enterprise adoption.
Recent public information indicates that a major model team is advancing next-generation model R&D, with records mentioning lightweight model entries, multiple post-training branches, and training environments for quantitative finance and coding tasks. Combined with previously disclosed ultra-large parameter scale concepts, these clues suggest that the focus of next-stage LLM R&D may no longer be just “making models bigger,” but rather building a complete self-improvement system around data, environments, agents, and feedback mechanisms.
It should be emphasized that public clues do not equate to official product specifications. Model names, parameter scales, data targets, and R&D phases may change with experimental results. Therefore, a more valuable approach is to extract technical trends from this information and analyze the underlying training paradigms and engineering challenges.
1. From Parameter Expansion to Systematic Scaling
Traditional LLM capability enhancement relies on three variables: parameter size, training data, and computing power. As high-quality internet text approaches its utilization limit, the marginal benefit of merely adding general corpora is decreasing. Future scaling will not only be reflected in continued parameter expansion but also in the sustained growth of post-training data, task environments, tool-calling trajectories, and agent experiences.
Post-training refers to aligning the model with practical application needs through supervised fine-tuning, preference optimization, reinforcement learning, and task feedback after base pre-training. Unlike pre-training, which primarily learns language patterns, post-training focuses on whether the model can complete specific tasks, such as:
- Breaking down complex goals;
- Continuously calling tools;
- Identifying and correcting errors;
- Maintaining context consistency over long-running operations;
- Adjusting strategies based on environmental feedback.
This means model competition is shifting from “knowledge coverage” to “task completion rate.” A model with a larger parameter size that cannot reliably execute complex tasks may not be more valuable than a smaller-scale system with a well-designed feedback loop.
2. The True Meaning of 100T-Level Data Targets
“100T-level data” is easily misunderstood as simply accumulating data volume, but scale itself does not equal effective training value. For next-generation models, what truly matters is whether the data possesses verifiability, executability, and iterability.
The first category is foundational knowledge data, including text, code, mathematical derivations, and structured knowledge. This data builds the model’s language understanding, knowledge association, and basic reasoning capabilities.
The second category is task process data, recording how the model analyzes problems, formulates plans, calls tools, executes operations, and handles exceptions. Compared to simple Q&A results, process data is better suited for training long-horizon task capabilities.
The third category is environmental interaction data, meaning the execution trajectories generated by the model in simulated or real task environments. For example, a coding agent modifying code, running tests, reading logs, and fixing issues repeatedly in an isolated environment; a financial analysis agent performing calculations, verifying conclusions, and generating reports on controlled datasets.
The fourth category is evaluation and error-correction data. The system must not only save success cases but also record failure reasons, invalid steps, resource waste, and error recovery processes. Only by structuring failures can the model learn to avoid repeating them.
Therefore, the core of the 100T-level target is not “collecting more files,” but establishing a high-quality data factory covering tasks, processes, results, and evaluations. Data generation, cleaning, deduplication, desensitization, quality assessment, and version management will become critical factors determining the final outcome.
3. Why 100% RSI Requires a Closed-Loop System
RSI is typically understood as Recursive Self-Improvement, where a system uses its own execution results to improve the model, toolchain, or operating framework, and then uses the improved system to execute the next round of tasks. The “100%” is better understood as a research goal, indicating that key aspects of the agent R&D process should have automated feedback capabilities as much as possible, rather than claiming the system is fully manual-free.
A complete self-improvement closed loop includes at least the following steps:
Task definition↓Agent execution↓Result and process logging↓Automatic evaluation and error attribution↓Improvement plan generation↓Update prompts, tools, data, or model↓Re-execute and compare results
In this process, the hardest part is not having the model “suggest improvements,” but determining whether the improvements are genuinely effective. Without stable evaluation, the system might only change its output style, or even show improvement on certain samples while degrading on overall tasks.
Therefore, an RSI system must simultaneously monitor four types of metrics:
- Task accuracy: whether the result meets the goal;
- Stability: whether it remains consistent across different inputs and environments;
- Efficiency: the time, call counts, and computing resources required to complete the task;
- Maintainability: whether improvements are easy to reproduce, roll back, and audit.
Only when quality improvement and cost reduction occur simultaneously can an improvement be considered to have engineering value.
4. Why Coding Agents Are the First Breakthrough
Coding tasks are naturally suited for establishing automated feedback mechanisms. Code can be compiled, tested, run, and statically analyzed, and errors can usually be located through logs, exception messages, and test results. This verifiability makes coding agents more suitable for self-improvement experiments than open-ended writing or complex real-world decision-making.
A relatively complete coding agent workflow typically includes:
- Reading requirements and splitting tasks;
- Checking existing code structure;
- Formulating a modification plan;
- Writing or modifying code;
- Executing tests and static checks;
- Analyzing failure logs;
- Performing local fixes;
- Repeating validation and submitting results.
A further research direction is enabling the agent to not only modify business code but also optimize its own operating framework. For example, adjusting task decomposition strategies, improving context organization, reducing invalid tool calls, or automatically generating more comprehensive test data.
However, such capabilities must run in isolated environments with permission boundaries, resource quotas, and version rollback mechanisms. Otherwise, automated system modifications might introduce hidden defects or even cause data security and operational stability issues.
5. Expanding from Coding to Finance and Healthcare Scenarios
Quantitative finance and healthcare tasks have high professional barriers and can better test the agent’s long-term planning and reliability. However, these domains cannot simply copy the evaluation methods of coding tasks.
Financial scenarios require close attention to data timeliness, computational accuracy, risk constraints, and conclusion interpretability. Strategies or analysis results generated by the agent must undergo historical data backtesting, extreme market testing, and manual review; they cannot be judged solely by the quality of language expression.
Healthcare scenarios place greater emphasis on evidence sources, scope of application, privacy protection, and safety boundaries. Models can assist in information retrieval, case structuring, and process management, but should not directly replace critical diagnostic decisions without professional review.
Therefore, when expanding from coding agents to finance and healthcare agents, task environments, evaluation criteria, and permission systems must be redesigned. General capabilities can be transferred, but industry rules cannot be directly copied.
6. How to Let Models Know If They Are Getting Stronger
The biggest challenge of self-improvement is that the evaluation system might be “gamed” by the model. If relying on a single score, the model might achieve superficial improvements by catering to the evaluation format, memorizing test samples, or adding invalid steps.
A more robust approach is to build a multi-layered evaluation system:
- Offline benchmarks: for quick comparison of different versions;
- Randomized task sets: to reduce overfitting risks;
- Adversarial samples: to test boundary conditions and exception handling;
- Long-horizon tasks: to observe stability during continuous execution;
- Manual spot-checks: to identify issues undetectable by automated metrics;
- Online shadow evaluation: to observe actual performance without affecting real business operations.
Additionally, the concept of “scalable correctness” should be introduced. Methods effective in small-scale experiments may not hold true when data volume, model size, or task complexity increases. R&D teams need to compare training curves, benefit curves, and cost curves at different scales to determine whether a technique represents a stable pattern or an accidental result.
7. Engineering Suggestions for Enterprise Adoption
If enterprises want to build similar agent self-improvement systems, they should start with narrower tasks rather than pursuing full automation immediately.
First, establish a repeatable task environment. The environment should contain fixed inputs, clear goals, observable states, and standardized feedback.
Second, perfect the data closed loop. All execution records should include task versions, tool calls, exception information, final results, and evaluation scores, with proper desensitization and permission management.
Third, adopt gradual updates. Any automatically generated strategy, prompt, or code should first enter an experimental branch, passing offline and shadow tests before gradually expanding its scope.
Fourth, retain human oversight. Humans need not participate in every execution but should be responsible for setting high-risk rules, auditing evaluation criteria, and handling issues that cannot be automatically attributed.
Fifth, focus on unit yield. When evaluating the system, look not only at accuracy but also calculate the resource consumption, failure recovery cost, and maintenance cost per task.
Overall, the core competitiveness of next-generation LLMs is shifting from standalone model capabilities to a systematic capability of “model plus environment plus data plus feedback.” The 100T-level data target provides a scale foundation, coding agents provide a verifiable entry point, finance and healthcare tasks expand application boundaries, and 100% RSI represents a longer-term R&D vision: letting intelligent systems gradually participate in data generation, task execution, error analysis, and capability iteration.
This route is still far from full automation, but its engineering direction is relatively clear. Whoever can build a stable, auditable, rollback-capable, and scalable self-improvement closed loop will be more likely to gain a sustained advantage in the next phase of agent competition.
