Large Models Toward 100% RSI: Post-Training and Closed-Loop Agent Evolution
Public signals around next-generation large models point to a shift: capability growth is moving beyond parameter and pretraining scale toward post-training, verifiable task environments, and recursive self-improvement (RSI) loops in which models help design, execute, evaluate, and generate data for the next round of optimization. This article explains the 100% RSI goal, why coding agents are a practical starting point, how environments and data governance must work, and which engineering components and metrics determine whether self-improvement is real.
Recent public data pages and research notes mention next-generation large models and fast-inference variants. The details are not enough to confirm a finished product or final metrics, but they do suggest a change in research focus. Scaling parameters and pretraining data is no longer the only path to stronger capability.
“100% RSI” here means a highly automated recursive self-improvement target. RSI is not simply having a model generate more text. The intent is for the model to take part in task design, execution, evaluation, error analysis, tool modification, and training-data production, then feed those results into the next round of model or agent optimization. If that loop is stable, gains no longer depend only on human labels and fixed training cycles. Experience can accumulate in verifiable task environments.
From Parameter Scaling to Post-Training Expansion
Model capability usually comes from three layers: pretraining, post-training, and application-side agents.
Pretraining learns broad language, knowledge, code, and reasoning patterns. It builds foundations, but it is often not enough for goal decomposition, tool use, error recovery, and long-horizon planning on complex tasks.
Post-training is closer to real use. Through supervised fine-tuning, preference optimization, reinforcement learning, and executable environments, models learn how to complete specific goals. In programming, a model must not only write code but also understand project structure, run tests, locate bugs, change implementations, and verify results. Static text matching cannot measure this; executable environments and clear feedback are required.
One notable research pattern is to post-train multiple internal models on different tasks, then merge useful experience into the next base model. Compared with training a single model from scratch, this emphasizes specialization and transfer.
Different models can focus on:
- Code generation and refactoring
- Long-chain reasoning
- Tool use and task planning
- Rule execution in vertical settings such as finance or healthcare
- Automatic evaluation, error attribution, and data filtering
After execution, the system collects successful traces, failed traces, tool-call logs, test results, and human corrections. Quality filtering and reward modeling turn valuable parts into later training samples.
This “multi-model exploration, experience filtering, base-model absorption” path expands the post-training search space. Models are not only learning existing answers; they try strategies in an environment and extract better behavior from outcomes.
Task Environments as the Foundation of Agent Evolution
Without a reliable task environment, self-improvement stays conceptual.
A coding agent at least needs a repository, dependency installation, build and run, tests, log collection, and pass/fail judgment. After a patch, the environment should tell whether tests pass, performance drops, new security issues appear, and whether the original requirement is actually solved.
Unlike ordinary Q&A, a task environment should have:
1. Verifiable outcomes
Tasks need relatively clear success criteria: tests passing, outputs meeting constraints, or a specified operation completing. Stronger verifiability makes RL and automatic evaluation easier.
2. Recordable process
The system should keep not only the final answer but also reasoning steps, tool calls, commands, errors, retries, and time cost. Full traces are required to explain failure.
3. Decomposable feedback
Failure may come from planning, code, environment setup, or misunderstanding the requirement. Feedback should not be a single success/fail label. It should cover dimensions such as correctness, efficiency, stability, resource use, and safety.
4. Extensible environments
Teams must keep adding task types and difficulty. A small fixed set leads to overfitting, and scores stop representing real ability.
Quantitative analysis environments and code sandboxes push post-training from abstract reasoning toward complex industry work. The former needs data cleaning, metric calculation, risk constraints, and explanation. The latter needs sustained operation inside real software workflows.
Why Coding Agents Are a Starting Point for RSI
Programming is a good RSI research domain because it is executable, iterative, and evaluable.
Generated code can immediately receive feedback from compilers, test frameworks, or runtimes. If results are wrong, the agent can read logs, edit, and rerun. That cycle fits reinforcement learning.
A typical coding-agent loop:
Receive requirements↓Analyze project structure and constraints↓Make an implementation plan↓Generate or modify code↓Run tests and static checks↓Read error logs↓Find root cause and replan↓Submit results and write an experience record
A stronger system can also let the agent evaluate its own behavior, for example:
- Whether it read unnecessary files
- Whether it made many useless attempts
- Whether it repeated the same commands
- Whether it could have detected dependency issues earlier
- Whether it used cheaper verification
- Whether weak planning caused later rework
These signals can improve prompts, tool policies, task decomposition, and runtime frameworks. The agent is improving not only final code, but also how work gets done.
From Runtime Optimization to Training-Data Generation
Agent self-improvement usually has three layers.
The first is runtime efficiency: reduce useless calls, repeated search, and unnecessary context to cut time and compute.
The second is framework behavior: use past failures to adjust decomposition, tool choice, exception handling, and context management. If version conflicts often cause errors, add environment checks before code changes.
The third is self-generated training data: turn successes, failures, and corrections into samples for later models. Data should not be ingested wholesale. It needs filtering, deduplication, quality review, and safety checks.
Self-generated data has several risks.
Error amplification: unrecognized bad traces can teach the next model the same mistakes, or worse.
Distribution collapse: if the model only trains on tasks it already handles, coverage shrinks.
Evaluation contamination: overlap with test data can raise scores without better generalization.
A data loop therefore needs independent validation sets, external task sets, hard examples, and human sampling. High-risk domains also need rule checks, audit trails, and permission isolation.
Extending from Code to High-Risk Domains Such as Healthcare
Coding is a start, not a template for every domain.
In healthcare, outputs may involve diagnostic advice, medication risk, and patient privacy. The cost of error is far higher than typical code generation. Agents cannot self-optimize on fluency or a single score. They need professional rules, evidence citation, multi-person review, and safety bounds.
A cautious path is:
- Start with low-risk work such as information organization, literature search, and structured summaries
- Move to assisted analysis, case stratification, and workflow management
- Require mandatory human review for clinical decisions
- Keep evidence sources, reasoning, and version history for every output
- Use independent evaluation sets to check real gains, not just fit to internal data
RSI is not “let the model run fully unsupervised.” It is an engineering system of models, environments, evaluators, and safety controls. Higher autonomy demands stronger boundaries and auditability.
What a 100T-Scale Data Goal Implies
If research aims at hundred-trillion-scale data, the hard part is not only storage. Quality and training organization matter more.
Large corpora may include code, documents, interaction traces, tool logs, simulated tasks, error cases, and domain knowledge. More data does not linearly increase capability. Low-quality, duplicated, or contradictory data can raise cost and hurt stability.
A 100T-scale goal must address:
- Legal and traceable sources
- Deduplication of repeated and templated content
- Detection of noise, malicious instructions, and wrong answers
- Balance across domains
- Mixing dynamic and static data
- Strict isolation of train, validation, and test sets
- Unified management of versions, processing rules, and quality metrics
Agent-generated data should record context: task goal, tools, execution, judgment, and human correction. Without that metadata, sample trust is hard to judge and capability changes are hard to explain.
Engineering Components for a Reliable Loop
A sustainable self-improvement system typically needs:
1. Task orchestration
Distribution, state, retries, timeouts, and resource scheduling, plus checkpoint recovery for long jobs.
2. Isolated execution
Code and tools run in permission-controlled sandboxes that limit files, network, and resources so generated content cannot affect production.
3. Trace and logging
Full records of inputs, outputs, tool calls, errors, latency, and resource use, with search, aggregation, and anomaly analysis.
4. Automatic evaluation
Tests, rule checks, result comparison, and quality scores by task type. Open-ended tasks may use multiple evaluators, but evaluators must not be gamed.
5. Data governance
Deduplication, filtering, labeling, versioning, access control, and traceback of bad samples.
6. Monitoring and safety
Track success rate, failure types, cost, latency, abnormal behavior, and permission use. Large-scale errors or abnormal calls should trigger automatic pause.
How to Tell Whether RSI Is Actually Working
Do not judge self-improvement by one-shot accuracy. Watch long-term returns, including:
- Whether task success keeps rising
- Whether generalization to new and unseen tasks improves
- Whether average steps decrease
- Whether tool calls and compute drop
- Whether error recovery improves
- Whether generated-data quality stays stable
- Whether errors accumulate or capability regresses
- Whether the model learns to exploit evaluation loopholes for fake high scores
Reliable RSI should improve capability, reduce cost, strengthen generalization, and keep risk under control. Higher scores from more retries, more tools, or overfitting a fixed test set are not genuine self-improvement.
Overall, the next stage of large-model evolution is shifting from “train a bigger model” to “build a system that can keep learning and optimizing.” Post-training environments, coding agents, automatic evaluation, training-data generation, and infrastructure form a new growth chain.
100% RSI remains a hard, long-term goal. It needs stronger reasoning and execution, plus solutions for data reliability, evaluation trust, permission safety, cost control, and capability regression. For developers, the key signal is not a single model’s parameter count, but whether a verifiable, traceable, rollback-capable agent loop exists. Self-improvement has engineering value only when every run yields high-quality experience that still holds on independent tasks.
