Does scaling toward AGI depend on what System-1 lets System-2 execute?

Every step costs. Most teach very little.

We call any exchange between an AI system and its data, its computation or the world an interaction. Interactions take different forms, but they share one awkward property: you pay before you see what you got.

More interactions help, but each one helps less than the last. Reasoning tokens that don't change the answer, training runs that produce no learning signal, and robot steps that repeat what is already known all burn real resources. So the bottleneck is shifting. It is no longer only how many interactions a system can handle, but which ones are worth their cost.

The easy supply is running out

For a decade, the answer to "how do we get better?" was "collect more". That frontier is closing.

• Human data is finite. Pretraining already folds most recorded text into one model, and public text may be exhausted within this decade.
• Good data is scarcer still. The examples that teach the most are a small slice of that stock.
• Synthetic data trades quantity for coverage. It can refill the pool, but the space of things to synthesize is enormous. A robot alone would need scenes, objects, dynamics, lighting and sensors covered. The real question becomes which synthetic examples are worth making.
• Some interactions are slow by nature. In science, robotics and clinical work, data arrives one experiment or one measurement at a time. No amount of compute speeds up a chemical reaction.
• Self-improvement makes it sharper. An agent that learns after deployment and interacts indiscriminately spends its budget on experiences that teach it nothing.

Wasted effort, in one picture

Reasoning models are often trained with verifiable rewards: give the model a problem, let it try several times, and score each attempt automatically. Popular methods like GRPO learn by comparing attempts at the same problem against each other. If every attempt gets the same score, there is nothing to compare, and the model learns nothing from that problem.

A large share of a typical training pool falls into the first two rows. If you could tell in advance which problems will be "just right", you could spend the generation budget only on those. The chance that a problem teaches anything follows from its pass rate $p$ and the number of attempts $G$:

As the model improves, more problems drift toward a 100% pass rate and stop teaching. Predicting $p$ before generating is exactly System-1's job in this setting.

Physical systems face the same issue with higher stakes. Real-world trials can't be run in parallel for free, and they take real time. When a robot must generalize across many conditions, which conditions it practises matters as much as how many.

When AI starts teaching AI

We sketch a trend we call the super parrot hypothesis. It is an illustration of a direction, not an established history.

This trend makes the efficiency problem harder, not easier. Every self-generated example is paid for with the system's own compute, and many teach little: problems it already solves, reasoning tokens that don't change the answer, tasks it has already mastered. A system that teaches itself needs an internal sense of what is worth doing before it does it.

Co-design, not a cascade

Pairing a small model with a big one is not new. A static cascade trains a fast router once and sends the hard requests to a large model. That works when difficulty never changes. Here it does: what is useful for System-2 shifts with every update, so System-1 has to keep learning from System-2's results. The difference is feedback and joint optimization, not the number of models.

AlphaZero is the familiar precedent: its strength came from a policy-value network and a tree search that trained each other, not from deeper search alone. A stronger System-2 raises what can be achieved. A well-calibrated System-1 decides how much of it you get per unit of cost and latency.

The framework, piece by piece

Both systems are defined by their role, not their model family. System-1 takes a candidate (a prompt, a task, a query, a tool call) and returns a score, not a solution, at a cost $c_{\mathrm{pred}} \ll c_{\mathrm{exec}}$. System-2 performs the interaction, and only on candidates System-1 admits.

• Represent. Each candidate becomes a compact embedding: a frozen language-model encoder for prompts, or a graph or transformer encoder over a task's structure for robots.
• Predict. A small model outputs a predicted value and its uncertainty. When costs are equal, the best way to use those outputs is to rank by the calibrated mean: executing the top $B$ by $\mathbb{E}[U\mid \hat U]$ maximizes expected utility among all rules that see only the predictions.
• Gate. Admit candidates whose score clears a threshold $\kappa_t$. A controller nudges it to hold a target admission rate $\rho^*$: $\kappa_{t+1} = \kappa_t + \alpha_\kappa\big(n^{\mathrm{adm}}_t/n - \rho^*\big)$.
• Execute. System-2 does the costly work on what was admitted. A small audit sample of rejected candidates is executed too, so System-1's misses can be detected.
• Learn. Outcomes are logged and used to refit System-1, while System-2 learns from the same outcomes.

The two systems learn on different clocks. Writing $\theta$ for System-2 and $\phi$ for System-1, one round of co-design is a refit of System-1 followed by a gated step of System-2:

Neither update is defined without the other. System-1 adapts quickly to realized outcomes, and System-2 improves slowly along gradients sampled through the gate. That separation of timescales is what keeps the loop stable.

Beyond the gate, co-design fixes three interfaces:

Because System-1 sees every candidate before System-2 acts, it is also a natural place to enforce cost, irreversibility and safety limits. The same gate can be stacked across levels, such as motor, skill and plan, with each level gating the one below.

Examples: one loop, four settings

The same predict, gate, execute, learn pattern runs in training and deployment, in software and in the physical world. What changes is what counts as useful and what counts as cost.

ρ_u: how much of the effort is worth it

Classic scaling laws describe performance in terms of parameters N, data D and compute C. We add a coordinate that describes how well those three turn into capability: ρ_u, the share of candidate interactions whose usefulness clears a stated bar.

Performance = f( N, D, C ; ρ_u )

ρ_u is not a new resource you can buy. It comes out of the learning process itself, and it always depends on how "useful" is defined. Useful prompts for training, risky tasks for a robot and hard questions for test-time reasoning give different values. Two readings of it matter:

Our prediction is that ρ_u falls as a system improves, because mastered tasks stop teaching anything. If so, that decay may explain part of why returns diminish, and scaling would be better measured in informative compute than in total compute.

Skipping the useless share, 1 − ρ_u, helps on every axis at once. Fewer rollouts and updates save compute and data. Sending each task only to the model it needs reduces how much capacity is switched on. Gating during training lowers cost, gating at test time cuts latency, and focusing both on informative interactions raises success per unit of either.

The math in brief

The paper states these results for any declared utility $u$, with $\rho_u$ the share of candidates whose true utility clears a floor fixed in advance. Each holds under the assumptions noted, and each comes with its own proof in the paper.

1. The gate

   $$\pi_{\mathrm{CI}}(i \mid \mathcal{H}_t) \;=\; \frac{1}{Z_t}\, e^{\beta\,\hat u(i\mid\mathcal{H}_t)}\; \mathbf{1}\!\left[\hat u(i\mid\mathcal{H}_t) \ge \kappa_t\right]$$

   The threshold $\kappa_t$ decides which candidates are allowed, and $\beta$ decides how sharply the best ones are preferred. As $\beta\to\infty$ it becomes "pick the top candidate". As $\beta\to 0$ it becomes a plain filter. If nothing clears the bar, the system abstains.

2. Budgets turn the gate into a price

   $$\begin{gathered}\max_{x\in[0,1]^{\mathcal I}} \sum_i x(i)\,\hat u(i) \;\;\text{s.t.}\;\; \sum_i x(i)\,\mathcal{C}(i)\le\Gamma \\[4pt] \Longrightarrow\quad x^\star(i)=\mathbf{1}\!\left[\hat u(i)\ge\lambda\,\mathcal{C}(i)\right]\end{gathered}$$

   Spending a budget well is a knapsack problem. The answer is to admit candidates in order of value per unit cost, with the budget setting the price $\lambda$. Prompt selection, task sampling, adaptive halting, tool gating and model routing are all this rule with a different menu, utility and cost.

3. Predicting first beats running everything and filtering

   $$\frac{\mathcal{C}_{\mathrm{CI}}}{\mathcal{C}_{\mathrm{react}}} \;=\; \rho_u + r, \qquad r=\frac{c_{\mathrm{screen}}}{c_{\mathrm{exec}}}$$

   To find the useful candidates, predicting first costs a fraction $\rho_u + r$ of executing them all, so the speedup approaches $1/\rho_u$ as screening gets cheap.

   Assumes a perfect screen. Audit samples and refitting System-1 add to the cost.

4. With an imperfect System-1

   $$\frac{\mathrm{IIE}^{\mathrm{CI}}}{\mathrm{IIE}^{\mathrm{unc}}} \;=\; \frac{1}{\rho_u}\left(1+\frac{\mathrm{fp}\,(1-\rho_u)+r}{(1-\mathrm{fn})\,\rho_u}\right)^{-1}$$

   Interaction information efficiency (IIE) is useful work per unit of total cost. False positives ($\mathrm{fp}$), misses ($\mathrm{fn}$) and prediction cost ($r$) each shrink the gain below $1/\rho_u$. The demo above computes exactly this ratio. Misses also reduce the yield, so efficiency and yield are reported together: an aggressive gate can look efficient while starving the learner.

   Shown for equal execution costs and dead candidates carrying no utility. The paper gives the general form.

5. Bigger pools without more rollout memory

   $$M_{\mathrm{CI}}(n) \;=\; \Theta\!\left(B\,G\,L\,d_{\mathrm{model}} + b\,d_e + B\right)$$

   A candidate that is scored rather than executed needs only an embedding, so peak memory does not grow with the pool size $n$. Larger pools contain better candidates, and System-1 can search them at no extra rollout memory.

   Compared with synchronous execute-then-filter evaluation.

6. When a cheap predictor picks exactly right

   $$\mathcal{R}_T \;\le\; 2\,T\,B\,\varepsilon_\phi\cdot\mathbf{1}\!\left[\,2\varepsilon_\phi \ge \mathrm{gap}_{\min}\right]$$

   If System-1's error $\varepsilon_\phi$ is under half the gap between the worst candidate worth keeping and the best one worth dropping, it selects exactly what an oracle would, with zero regret. Beyond that, regret grows only linearly. A high-probability version adds a term for blind spots, which dominate once average error is small.

7. System-1 should grow with System-2

   $$k' > k \;\Longrightarrow\; S^\star(k') \;\succeq\; S^\star(k)$$

   As System-2 becomes more expensive by a factor $k$, the best System-1 size $S^\star$ never shrinks. Scaling System-2 dilutes System-1's own cost but not the cost of its mistakes, so accuracy becomes cheaper to buy. This fixes the direction of co-scaling, not its rate.

   Assumes System-1's error curves don't change as System-2 scales.

8. Test-time reasoning

   $$\frac{\text{gated compute}}{\text{full compute}} \;\le\; \rho_u^{\mathrm{tt}} + \frac{1+c_{\mathrm{pred}}}{C} + \delta_{\mathrm{FP}}, \qquad \text{accuracy loss} \le \delta_{\mathrm{FN}}$$

   Take one probing step, predict whether the full budget $C$ would change the answer, then stop or continue. The saving approaches $1/\rho_u^{\mathrm{tt}}$, and accuracy drops at most by the share of queries wrongly halted.

   The paper flags that neither premise has been measured at test time yet.

9. Agents using tools

   $$\mathbb{E}[\mathcal{C}_{\mathrm{CI}}] \;\le\; \big(\rho_u^{\mathcal C} + r + m\,\varepsilon_\phi R_c\big)\,\mathbb{E}[\mathcal{C}_{\mathrm{all}}]$$

   Calling only the actions predicted to matter costs about the useful share of a call-everything agent, plus prediction and error terms, with accuracy within $N m\,\varepsilon_\phi$ of it.

   Holds for separable actions. Long click sequences need whole sub-trajectories scored instead.

10. A testable scaling hypothesis

    $$\mathcal{L}_{\mathrm{CI}}(\mathcal{C}) = \mathcal{L}_{\mathrm{base}}\!\left(\mathcal{C}/\rho_u\right), \qquad \mathcal{C}_{\mathrm{info}}(\mathcal{C}) = \int_0^{\mathcal{C}} \rho_u^{\mathrm{exec}}(c)\,dc$$

    With a constant $\rho_u$ and a perfect gate, the loss curve simply shifts left by $\ln(1/\rho_u)$ on a log-compute axis. If $\rho_u$ decays as the model improves, curves should line up better against informative compute $\mathcal{C}_{\mathrm{info}}$ than against total compute. The stronger hypothesis is that gating also changes the scaling exponent. Both can be tested.

Our line of work on co-design

The position grows out of System-1 and System-2 pairs our group has built and tested across settings. In each, a small predictor learns from the shared optimization history and decides where a much larger system spends its effort.

Related work from the group studies why the useful band of prompts drifts during RL (Listwise Policy Optimization). As the paper notes, these results illustrate the framework rather than validate it. The decisive test is measuring $\rho_u$ directly.

What we claim, and how sure we are

This is a Perspective, so we separate what we assume, argue, hypothesize and predict.

1. Premise assumed

   Future digital and robotic systems may be limited more by interaction efficiency than by parameters or data.

2. Position argued

   Progress toward general intelligence should co-design a cheap System-1 with a costly System-2, judging interactions before they run and skipping those predicted to teach nothing.

3. Hypothesis proposed and testable

   The density of useful interactions, ρ_u, is an important factor in how efficiently resources become capability.

4. Prediction not yet measured

   ρ_u decays as the system improves. This may account for part of the diminishing returns, so scaling laws are better written in informative compute.

Under stated assumptions, the paper proves screening savings, a regret bound tied to predictor error and the utility margin, and test-time, agentic and co-scaling cost bounds.

Our answer: a qualified yes

Co-design is promising wherever interactions are costly, unequal in value and predictable in advance. The decisive next step is measurement: track ρ_u as systems learn, compare scaling curves at matched informative compute, and test whether co-design changes more than a constant factor.

Cite this work

@misc{wang2026scaling,
  title  = {Does Scaling Toward AGI Depend on What System-1
            Lets System-2 Execute?},
  author = {Wang, Qi and Qu, Yun and Cai, Lizhou and Zou, Heming and
            Chi, Haoang and Lv, Yiqin and Li, Xiang and Feng, Haiyan and
            Ge, Mengyu and Geng, Yize and Jiang, Yuhang and Mao, Yixiu and
            Ji, Xiangyang},
  year   = {2026},
  note   = {Tsinghua University}
}