Not All Experience Belongs in the Weights: Component Routing for Self-Improving GUI Agents

Beining Wu; Zihao Ding; Jun Huang

cs.AIOct 1, 2026

Not All Experience Belongs in the Weights: Component Routing for Self-Improving GUI Agents

Authors: Beining Wu, Zihao Ding, Jun Huang

Organizations: Department of Electrical Engineering and Computer Science, South Dakota State University

Abstract

Self-improving GUI agents keep the trajectories they produce and return them to the agent, by fine-tuning or by retrieval into the prompt, and studies that compare the two destinations disagree. We attribute this to the unit of experience: a trajectory bundles items with different properties, so a conclusion about the bundle depends on its mix. To address this, (i) we introduce component routing, which splits the experience into locators, procedures, state facts and lessons and sends each component to the context or to the weights, compared on the same items across three backbone families, two environments and three seeds. One pool has two destinations: locators and lessons win in the weights, procedures and state facts in the context. (ii) We fit a rule in two properties measured before any training, recurrence and state-conditionality; it recovers the destination of a held-out backbone family in 24 of 24 cells, two interventions move a component toward the boundary, and routing by the rule beats every whole-trajectory baseline and, by +3.5 points on average, the better single destination of each backbone. (iii) We identify how training and producer-consumer differences change the value of the two destinations: note readout decreases after the same component is written into the weights, most for the items that recur most, context gains increase with the information gap, and weights gains decrease with the policy gap. Code and data will be released.

Figures & tables

Figure 1 : Component routing. (a) The four components on the plane of recurrence $r$ and state-conditionality $\kappa$ , measured before any training; fill marks the winning destination on held-out tasks, the dashed line is the fitted boundary, the arrow one intervention. (b) Held-out success, mean over three backbones and three seeds; arrows: gain over whole-trajectory fine-tuning and the higher single-destination bar.

Figure 2 : A motivating example. G recurs across tasks and goes to the weights; P matters only on the preview screen and stays in context. Screens are illustrative.

Figure 3 : Overview. Whole-history reuse (left) against component routing: (A) profile every item of the pool, (B) compare both destinations per component (middle), and reuse each component from its destination on a new task (right).

Figure 4 : Components split by destination. (a, b) Route gain $\Delta(c)$ per backbone on MobileGym and AndroidWorld, with 95 percent intervals; (c) gain of each destination over the base agent, pooled over backbones, one dot per backbone; (d) the pool on the plane of recurrence and state-conditionality, with the component summary of each backbone.

Figure 5 : Producer and consumer. (a) Gain from the procedures of a producer of each size, read from the context (solid) or written into the weights (dashed); filled markers train on the consumer’s own procedures only. (b) One consumer, five producers, three destinations.

Figure 6 : Readout after training. (a) Share of probed steps whose action changes after a note is read, before and after the same items are in the weights; (b) the after-to-before ratio against the component’s recurrence.

Figure 7 : The rule. (a) Component summaries of both environments on the plane, with the full-fit boundary (solid) and the three held-out boundaries (dashed); (b) held-out score against the observed route gain, 24 cells with 95 percent intervals. Small black-edged markers: halves of lessons and state facts split by item recurrence, used in no fit.

	MobileGym, gain over the base agent
Arm	GUI-Owl-8B	Qwen3-VL-8B	ScaleCUA-7B	$\Delta$
Procedures to the context	+5.3 ${}_{\pm\text{\scriptsize 0.7}}$	+5.2 ${}_{\pm\text{\scriptsize 0.2}}$	+5.1 ${}_{\pm\text{\scriptsize 0.0}}$	–
state condition removed	+1.4 ${}_{\pm\text{\scriptsize 0.8}}$	+1.8 ${}_{\pm\text{\scriptsize 0.1}}$	+0.8 ${}_{\pm\text{\scriptsize 0.4}}$	$\downarrow$ 3.9
Procedures to the weights	+0.3 ${}_{\pm\text{\scriptsize 0.6}}$	+2.0 ${}_{\pm\text{\scriptsize 0.9}}$	+0.6 ${}_{\pm\text{\scriptsize 0.3}}$	–
items copied $\times 8$	+3.3 ${}_{\pm\text{\scriptsize 0.6}}$	+6.1 ${}_{\pm\text{\scriptsize 0.3}}$	+3.9 ${}_{\pm\text{\scriptsize 0.5}}$	$\uparrow$ 3.5
State facts to the context	+4.6 ${}_{\pm\text{\scriptsize 0.4}}$	+5.4 ${}_{\pm\text{\scriptsize 0.6}}$	+4.9 ${}_{\pm\text{\scriptsize 0.3}}$	–

Table 1 : Interventions. Gain over the base agent (points) on MobileGym when one property of a component is changed: copying the training items raises the training dose of every key, as recurrence across tasks does; retrieving the notes by task text alone removes their state condition. Subscripts are the std over three seeds.

\Delta

is the shift from the unmodified route above it (

\uparrow

rise /

\downarrow

drop ), averaged over the backbones the arm has.

Figure 8 : Two illustrative episodes. Top: the locator comes from the weights, the state fact and the procedure from the context. Bottom: a note and a learned routine disagree on the entry type, and the agent takes the action of the note. Screens are illustrative.

	MobileGym			AndroidWorld
Arm	GUI-Owl	Qwen3-VL	ScaleCUA	GUI-Owl	Qwen3-VL	ScaleCUA	$\Delta$
Base agent	21.6 ${}_{\pm\text{\scriptsize 0.9}}$	16.7 ${}_{\pm\text{\scriptsize 2.0}}$	19.2 ${}_{\pm\text{\scriptsize 2.2}}$	23.6 ${}_{\pm\text{\scriptsize 1.9}}$	17.8 ${}_{\pm\text{\scriptsize 2.7}}$	24.0 ${}_{\pm\text{\scriptsize 3.0}}$	$\uparrow$ 14.1
Self-retry, three attempts	26.4 ${}_{\pm\text{\scriptsize 0.7}}$	20.6 ${}_{\pm\text{\scriptsize 1.6}}$	24.6 ${}_{\pm\text{\scriptsize 1.3}}$	26.1 ${}_{\pm\text{\scriptsize 0.7}}$	22.7 ${}_{\pm\text{\scriptsize 3.9}}$	27.2 ${}_{\pm\text{\scriptsize 4.0}}$	$\uparrow$ 9.3
Success-filtered fine-tuning	22.2 ${}_{\pm\text{\scriptsize 0.1}}$	17.3 ${}_{\pm\text{\scriptsize 1.4}}$	20.0 ${}_{\pm\text{\scriptsize 2.4}}$	24.1 ${}_{\pm\text{\scriptsize 2.0}}$	19.3 ${}_{\pm\text{\scriptsize 4.5}}$	23.3 ${}_{\pm\text{\scriptsize 3.2}}$	$\uparrow$ 13.4
Retrieve one trajectory	21.0 ${}_{\pm\text{\scriptsize 0.4}}$	15.1 ${}_{\pm\text{\scriptsize 2.0}}$	18.1 ${}_{\pm\text{\scriptsize 1.5}}$	22.8 ${}_{\pm\text{\scriptsize 4.1}}$	18.1 ${}_{\pm\text{\scriptsize 3.1}}$	22.1 ${}_{\pm\text{\scriptsize 2.3}}$	$\uparrow$ 15.2
Retrieve ten step records	22.9 ${}_{\pm\text{\scriptsize 1.1}}$	17.9 ${}_{\pm\text{\scriptsize 2.1}}$	20.8 ${}_{\pm\text{\scriptsize 2.2}}$	24.3 ${}_{\pm\text{\scriptsize 2.4}}$	19.5 ${}_{\pm\text{\scriptsize 3.6}}$	25.3 ${}_{\pm\text{\scriptsize 3.2}}$	$\uparrow$ 12.6

Table 2 : Routing against the alternatives. Held-out success (percent) on the same held-out instances with GUI-Owl-8B , Qwen3-VL-8B and ScaleCUA-7B ; subscripts are the std over three seeds. Self-retry uses three attempts per instance. The best value in each family is underlined ; the gain of routing over each row, averaged over the three MobileGym backbones, appears in the

\Delta

column (points; shade

\propto

gain).

Figure 9 : The three gaps. (a–c) Family-level gain of the procedures route against the information gap, the producer’s ability and the policy gap: 720 cells, binned means with 95 percent intervals from a bootstrap over the 15 producer–consumer pairs. (d) Five consumers on their own procedures: context, weights, and weights from own successes only.

Appendix figures & tables16 assets

Supplementary material from the paper’s appendix.

Appendix

Figure A.1 : Pool statistics. (a) Items per pool by component and backbone on MobileGym (dark) and AndroidWorld (light), mean over seeds with the seed range. (b) Distribution of item recurrence and (c) of state-conditionality over the items that have one, per component; MobileGym solid, AndroidWorld dashed.

	MobileGym				AndroidWorld
Component	Items	$\bm{r}$	$\bm{\kappa_{0}}$	Valued	Items	$\bm{r}$	$\bm{\kappa_{0}}$	Valued
Locators	9907	0.39	0.10	0.21	5544	0.38	0.09	0.20
Procedures	51052	0.05	0.66	0.06	25519	0.05	0.63	0.05
State facts	3980	0.32	0.56	0.53	1972	0.31	0.56	0.56
Lessons	24651	0.45	0.53	0.15	12775	0.44	0.50	0.15

Appendix

Table A.1 : Items per component. Number of items, mean recurrence

r

, median state-conditionality

\kappa_{0}

over the items that have one, and the share of items that have one, summed or averaged over the nine pools of each environment (three backbones, three seeds).

MobileGym	Training samples			Dev. accuracy
Arm	GUI-Owl	Qwen3-VL	ScaleCUA	GUI-Owl	Qwen3-VL	ScaleCUA
Locators to the weights	1211	1035	1056	0.952	0.949	0.959
Procedures to the weights	5721	5498	5798	0.932	0.946	0.946
State facts to the weights	476	450	401	0.954	0.954	0.961
Lessons to the weights	2854	2600	2763	0.931	0.934	0.940
All to the weights	10263	9583	10018	0.942	0.930	0.941

Appendix

Table C.1 : Training runs. Training samples and development token accuracy of every adapter, mean over the seeds the arm has. All adapters use LoRA rank 16,

\alpha

32, three epochs and learning rate

10^{-5}

with the vision tower frozen, except the two learning-rate rows, which train the samples of the default adapter; lessons and the second stage of all_W / routed use preference optimization with the same adapter configuration. The two halves of a component together train the samples of its full adapter.

Figure D.1 : The fit by fold. (a) The twenty-four cells, filled by the sign of their route gain, with the boundary of the full fit (solid) and of each fold (dashed). (b) Held-out score against the observed route gain with its interval. (c) Coefficients of the full fit and of the three folds.

		Routing coefficients			Agreement
Fit	Cells	$\bm{\alpha}$	$\bm{\beta}$	$\bm{\gamma}$	Sign
All 24 cells	24	11.29	5.73	1.28	24/24
Held out: GUI-Owl-8B	16	9.32	4.96	0.89	8/8
Held out: Qwen3-VL-8B	16	9.01	5.28	0.70	8/8
Held out: ScaleCUA-7B	16	9.16	4.86	0.94	8/8

Appendix

Table D.1 : The rule fit. Coefficients of

s_{\theta}(c)=\alpha\,r(c)-\beta\,\kappa_{0}(c)-\gamma

for the full fit and for each fold that holds out one backbone family; the last column counts held-out cells whose predicted sign matches the observed sign (in-sample for the full fit).

MobileGym		Pool coordinates		Route gain	Held-out rule
Component	Family	$\bm{r}$	$\bm{\kappa_{0}}$	$\bm{\Delta}$ [95%]	$\bm{w}$	$\bm{s_{f}}$	Pred. / obs.
Locators	GUI-Owl-8B	0.397	0.121	+5.9 [+4.9, +7.0]	1	+2.21	W / W
	Qwen3-VL-8B	0.388	0.064	+5.5 [+4.5, +6.6]	1	+2.47	W / W
	ScaleCUA-7B	0.374	0.106	+3.2 [+2.2, +4.3]	1	+1.97	W / W
Procedures	GUI-Owl-8B	0.052	0.673	$-$ 5.0 [ $-$ 6.0, $-$ 4.0]	1	-3.74	C / C
	Qwen3-VL-8B	0.051	0.645	$-$ 3.2 [ $-$ 4.2, $-$ 2.2]	1	-3.64	C / C

Appendix

Table D.2 : The twenty-four cells. Pool coordinates, route gain with its 95 percent paired-bootstrap interval (points), weight

w

(one half when the interval crosses zero), held-out score, and predicted / observed destination. The score of a cell comes from the fold that excludes its family.

	Assignment of the held-out family			MobileGym		AndroidWorld
Fit $\rightarrow$ score	GUI-Owl	Qwen3-VL	ScaleCUA	Single	Reverse	Single	Reverse
Half 1 $\rightarrow$ half 2	W CC W	W CCC / W CC W	W CC W	+3.7	+8.5	+2.4	+6.8
Half 2 $\rightarrow$ half 1	W CC W	W CC W	W CC W	+5.1	+9.3	+2.6	+6.6

Appendix

Table D.3 : Split of the held-out templates. The held-out templates of each environment are sorted by identifier and split alternately within each tier into two halves (113 and 111 on MobileGym, 29 and 29 on AndroidWorld). The rule is fitted with one family held out on the route gains of one half and scored on the other half. Assignments give the destinations of locators, procedures, state facts and lessons (MobileGym / AndroidWorld where the two differ); the gains on the scoring half are routing minus the better single destination of each family (Single) and minus the reverse assignment (Reverse), points, mean over the three families.

MobileGym		Half of the pool			Route gain	Held-out rule
Half	Family	Items	$\bm{r}$	$\bm{\kappa_{0}}$	$\bm{\Delta}$ [95%]	$\bm{s_{f}}$	Pred. / obs.
Lessons, high $r$	GUI-Owl-8B	4090	0.796	0.557	+2.4 [+1.4, +3.5]	+3.77	W / W
	Qwen3-VL-8B	3525	0.782	0.535	+2.2 [+1.2, +3.2]	+3.52	W / W
	ScaleCUA-7B	4092	0.806	0.506	+2.8 [+1.7, +3.8]	+3.99	W / W
Lessons, low $r$	GUI-Owl-8B	4472	0.134	0.549	$-$ 1.6 [ $-$ 2.6, $-$ 0.7]	-2.36	C / C
	Qwen3-VL-8B	4276	0.138	0.540	$-$ 2.1 [ $-$ 3.0, $-$ 1.1]	-2.30	C / C

Appendix

Table D.4 : The twelve halves. Lessons and state facts of every MobileGym pool split by item recurrence at the full-fit boundary for the mean

\kappa_{0}

of the component (

r=0.377

for lessons,

0.394

for state facts); each half goes to the context and to the weights on the same held-out instances. Items over the three seeds, pool coordinates, route gain with its 95 percent paired-bootstrap interval (points), score of the fold that holds the family out, and predicted / observed destination. No fit used the halves, and their predicted destinations were fixed before the runs.

Figure E.1 : Per-cell route gains and the split. (a) MobileGym and (b) AndroidWorld: the route gain of every backbone and component with its 95 percent interval. (c) Gain over the base agent on seen and unseen applications, pooled over backbones and seeds.

Figure E.2 : Copies and conflicts. (a) Gain of procedures and state facts written into the weights with each item copied one to eight times on GUI-Owl-8B ; dashed lines are the same components served as notes. (b) At the divergence steps of OpenApps, the share of steps that follow the note, the weights or neither, by recurrence bin, and (c) by component.

	MobileGym, gain over the base agent
Arm	GUI-Owl-8B	Qwen3-VL-8B	ScaleCUA-7B	$\Delta$
Procedures to the context	+5.3 ${}_{\pm\text{\scriptsize 0.7}}$	+5.2 ${}_{\pm\text{\scriptsize 0.2}}$	+5.1 ${}_{\pm\text{\scriptsize 0.0}}$	–
state condition removed	+1.4 ${}_{\pm\text{\scriptsize 0.8}}$	+1.8 ${}_{\pm\text{\scriptsize 0.1}}$	+0.8 ${}_{\pm\text{\scriptsize 0.4}}$	$\downarrow$ 3.9
signature read from the screen elements	+4.0 ${}_{\pm\text{\scriptsize 0.4}}$	+5.5 ${}_{\pm\text{\scriptsize 0.2}}$	+3.9 ${}_{\pm\text{\scriptsize 0.3}}$	$\downarrow$ 0.7
Procedures to the weights	+0.3 ${}_{\pm\text{\scriptsize 0.6}}$	+2.0 ${}_{\pm\text{\scriptsize 0.9}}$	+0.6 ${}_{\pm\text{\scriptsize 0.3}}$	–
items copied $\times 2$	+1.2 ${}_{\pm\text{\scriptsize 1.8}}$	–	–	$\uparrow$ 0.9

Appendix

Table E.1 : All intervention arms. Gain over the base agent (points) on MobileGym when one property of a component is changed: copying the training items raises the training dose of every key, as recurrence across tasks does; retrieving the notes by task text alone removes their state condition. The screen-element signature replaces the environment state in retrieval, the two learning rates train the same samples as the default

10^{-5}

, and the last block retrieves ten step records by task text or by the state signature. Subscripts are the std over three seeds; a dash marks an arm run on GUI-Owl-8B only.

\Delta

is the shift from the unmodified route above it (

\uparrow

rise /

\downarrow

drop ), averaged over the backbones the arm has.

	AndroidWorld: routing gain (points)
Family	vs. all to the context	vs. all to the weights	vs. reverse assignment
GUI-Owl-8B	$-$ 0.3 [ $-$ 2.6, +2.0]	+4.3 [+1.7, +6.8]	+5.6 [+2.9, +8.2]
Qwen3-VL-8B	+5.2 [+2.7, +7.6]	+5.0 [+2.4, +7.6]	+9.8 [+6.8, +12.6]
ScaleCUA-7B	+3.6 [+1.3, +5.9]	+3.2 [+0.7, +5.6]	+4.7 [+2.3, +7.3]

Appendix

Table E.2 : AndroidWorld contrasts. Held-out success of routing minus each aggregate arm (points) with 95 percent paired-bootstrap intervals over the 232 instances and three seeds of each family.

		Producer experience			Own experience
Consumer	Producer	Notes	Weights	Mixed	Practice
Qwen3-VL-4B	Qwen3-VL-4B	+1.5 ${}_{\pm\text{\scriptsize 0.7}}$	$-$ 0.3 ${}_{\pm\text{\scriptsize 0.7}}$	–	$-$ 0.3 ${}_{\pm\text{\scriptsize 1.0}}$
	Qwen3-VL-8B	+1.9 ${}_{\pm\text{\scriptsize 0.5}}$	$-$ 2.7 ${}_{\pm\text{\scriptsize 0.5}}$	$-$ 0.5 ${}_{\pm\text{\scriptsize 0.9}}$	–
	Qwen3-VL-32B	+3.1 ${}_{\pm\text{\scriptsize 0.5}}$	$-$ 1.9 ${}_{\pm\text{\scriptsize 0.7}}$	+0.0 ${}_{\pm\text{\scriptsize 0.4}}$	–
Qwen3-VL-8B	Qwen3-VL-4B	+2.2 ${}_{\pm\text{\scriptsize 0.5}}$	$-$ 2.3 ${}_{\pm\text{\scriptsize 1.0}}$	$-$ 0.8 ${}_{\pm\text{\scriptsize 0.6}}$	–
	Qwen3-VL-8B	+3.6 ${}_{\pm\text{\scriptsize 0.5}}$	+0.9 ${}_{\pm\text{\scriptsize 1.5}}$	–	+0.6 ${}_{\pm\text{\scriptsize 1.5}}$

Appendix

Table E.3 : Producers and consumers. Gain over the base agent (points) of the procedures route for every producer and consumer pair of Section 6 : notes from the producer, weights trained on the producer, an equal mixture, and the practice arm (the consumer trained on its own successful families only). Every adapter of this batch trains on 5 600 samples (1 900 for the 32B consumers); subscripts are the std over seeds.

	Locators		Procedures		State facts		Lessons
Consumer	Before	After	Before	After	Before	After	Before	After
GUI-Owl-8B	45	17	33	23	43	17	50	15
Qwen3-VL-8B	45	17	32	22	41	19	46	14
ScaleCUA-7B	46	16	35	22	42	19	50	15

Appendix

Table E.4 : Readout rates. Share of note-bearing steps (percent) whose action changes when the note is removed, before training (the base agent with the notes) and after (the adapter of the same component with the same notes), per consumer and component, pooled over seeds. The lower panel splits the items of each component into thirds of recurrence, pooled over consumers and seeds, and adds the after-to-before ratio.

			Gain over base (points)		Difference
Setting	Variant	Arm	Default	Variant	Shift
Jaccard thresholds	exact 0.8	C_F	+5.2	+4.7	$-$ 0.5
		C_G	+1.9	+1.5	$-$ 0.4
		C_L	+4.0	+3.4	$-$ 0.5
		C_P	+5.6	+5.3	$-$ 0.3
	relaxed 0.6	C_F	+5.2	+4.9	$-$ 0.3

Appendix

Table F.1 : Sensitivity. Gain over the base agent (points) on GUI-Owl-8B , seed 0, when one setting of the default arm is changed: the default arm, the variant, and their difference.

	Adapter training		Inference
Arm	Samples	GPU-h	Tokens (k)	Ratio
Base agent	–	–	13.2	1.00
Locators to the context	–	–	14.2	1.07
Procedures to the context	–	–	14.2	1.07
State facts to the context	–	–	14.2	1.07
Lessons to the context	–	–	14.2	1.07

Appendix

Table H.1 : Compute and tokens. MobileGym, GUI-Owl-8B , mean over seeds: training samples and GPU-hours of the adapter an arm trains, and prompt tokens per episode (thousands) with their ratio to the base agent. Training is booked per sample on one H100, 2.45 s for a supervised adapter and 5.40 s for an adapter with a preference stage; sampling one pool of 2440 episodes is booked at 3.7 GPU-hours at a fixed per-episode rate; arms without an adapter train nothing.

Explore similar work

Relevance Does Not Imply Applicability: Experience Activation for Personal GUI Agents
Sep 27, 2026Fuyao Zhang, Xuan Wang, Zherui Li +3Graphical User Interface Agents Graphical User Interface
NTU & Alibaba
Rethinking Experience Utilization in Self-Evolving Language Model Agents
May 8, 2026Weixiang Zhao, Yingshuo Wang, Yichen Zhang +6Self-Evolving Agents Decisions
1Harbin Institute of Technology · 2Huawei Technologies Co., Ltd
Routing Is Least Learnable Where It Is Most Valuable: Bounds on Representation Routing for Web Agents
Aug 6, 2026Jiaming Wei, Zekun Wu, Adriano Koshiyama +1Web Agents Strategic Agents
University College London / Holistic AI · Holistic AI / University College London · Holistic AI +1

Sep 27, 2026, cs.CVJ/K move · Enter open · S save

Relevance Does Not Imply Applicability: Experience Activation for Personal GUI Agents

Fuyao Zhang, Xuan Wang, Zherui Li, Jiaming Zhang+2

NTU & Alibaba

Graphical User Interface Agents Graphical User Interface Interaction History Task-Relevant Information Artificial Intelligence Assistants Proactive+1

Open paper AskPDF arXiv

Personal Graphical User Interface (GUI) agents rely on interaction history to infer what a user wants from ambiguous instructions and to anticipate recurring routines. Existing approaches retrieve task-relevant history and append it to the policy's context, implicitly assuming that experience relevant to a task remains useful for each decision within it. We find that this help is largely spent at the first decision: retrieved history strongly improves the opening step of an episode, yet provides little sustained benefit over the remaining 90% of steps, and offers weak guidance on whether a proactive suggestion is warranted. A relevant record may tell the agent where to begin, but not which past action applies to the current screen or whether a routine is due now. The underlying issue is that relevance does not imply applicability}: relevance is determined at the task level, whereas applicability depends on the situation at decision time. We therefore recast personalization as experience activation and introduce ExpActivator, a training-free framework that activates only the experience applicable to the current situation. During execution, ExpActivator matches each new screen to historical states in the frozen GUI backbone's latent space and supplies the corresponding action as a reference. Before execution, it activates a recurring intent only when the current time and scenario provide sufficient support, and otherwise abstains. Across four GUI backbones, ExpActivator improves within-trajectory step success by 28% on average, achieves the best personalized execution on every backbone while using about one-fifth as many history tokens, and reaches approximately 2.3

\times

the Matthews correlation coefficient of the strongest proactive baseline. Experience pays where it is activated, not where it is appended.

Abstract

Explore similar work

Relevance Does Not Imply Applicability: Experience Activation for Personal GUI Agents

Rethinking Experience Utilization in Self-Evolving Language Model Agents

Routing Is Least Learnable Where It Is Most Valuable: Bounds on Representation Routing for Web Agents