When to Compile a Computer-Use Agent? Measuring Payback and Making Compilation Decisions for Token Efficiency

Yulong Ming; Jie Xu; Zihan Wu; Xiaohua Jia

cs.AIOct 2, 2026

When to Compile a Computer-Use Agent? Measuring Payback and Making Compilation Decisions for Token Efficiency

Authors: Yulong Ming, Jie Xu, Zihan Wu, Xiaohua Jia

Organizations: City University of Hong Kong

Abstract

Compiling GUI procedures that agents execute repeatedly into programs can reduce their token costs. However, measuring payback and deciding when to compile have two challenges. First, compilation costs are uncertain because attempts can require repair and still fail to produce a usable program. Second, future reuse is unknown because tasks may stop arriving or GUI drift may stop the program from working. To address these challenges, we propose PACE (Payback-Aware Compilation from Experience), a system with a measurement protocol and an online compilation algorithm. The measurement protocol records successful and failed compilation costs, and compares agent and program execution costs on matched task inputs to estimate per-use savings and payback counts. Using these measurements, the online algorithm compares estimated future savings with compilation costs, including failed attempts, based on past task arrivals and compilation outcomes. It checks execution and compilation charges against a cumulative budget determined by observed task arrivals before allowing either action. Under stated action-cost assumptions, total cost after each arrival is at most $1+ε$ times the cost of running every task with the agent. For successful compilation attempts, estimated payback counts excluding source agent runs are 2-16 uses. In simulations using recorded task arrivals, PACE reduces token costs by 17.3% compared with ReAct, 24.9% with the AutoRPA adaptation, and 17.3% with the ToolPro adaptation on average ( $ε=0.25$ ).

Figures & tables

Figure 1: Challenges in deciding when to compile GUI procedures. Top: an example task and its agent and program execution paths. In (a), red cost bars mark failed compilation attempts. In (b), red bar segments show compilation costs left unrecovered when task arrivals stop or GUI drift ends reuse.

Figure 2: PACE’s measurement protocol. The source traces provide compilation experience, and their task prompts provide the model’s inputs for binding extraction during verification. Fresh task prompts are used to compare program and agent execution. The result panel combines execution measurements with the costs of successful and failed compilation attempts.

Family	Attempt cost (K tokens)	Before repair (3/3 required)	After repair (3/3 required)	Compilation-only payback (uses)	Trace-inclusive payback (uses)
Contacts	137 605 138	0/1/2 0/1/2 3/0/0	3/0/0 0/1/2 3/0/0	1.39 – 3.7	4.4 – 6.85
Markor delete	144 156 212	0/1/2 0/1/2 3/0/0	3/0/0 3/0/0 3/0/0	4.31 15.5 10	7.34 18.7 13.1
Calendar	3424 2872 1936	0/1/2 0/1/2 0/1/2	3/0/0 0/1/2 0/1/2	10.9 – –	13.9 – –
OsmAnd marker	3082 1701 1552	0/1/2 0/1/2 0/1/2	2/1/0 0/1/2 0/1/2	– – –	– – –
Calc table	2544 3057 3054	0/1/2 0/1/2 0/1/2	0/1/2 3/0/0 0/1/2	– 4.73 –	– 7.74 –
Writer memo	473 259 487	0/1/2 0/1/2 3/0/0	3/0/0 3/0/0 3/0/0	6.8 5.18 13.4	9.82 8.22 16.5

Table 1: Compilation costs, verification outcomes, and conditional payback. The two payback columns report

C/s

and

(C+kc)/s

, with

k=3

agent runs here. Payback excludes earlier failed attempts and future replacement. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Verification entries report passed/failed/untested task counts in that order; G marks a generation failure, and

\geq

marks a lower-bound cost.

Figure 3: PACE’s online compilation algorithm. After serving a task, PACE checks trace availability, estimated savings, and the cost budget before compiling. A failed check leads to waiting, while successful verification adds a program for later tasks. The two budget checks use the same cumulative cost budget.

Policy	Grid 1 mean ( $\times$ PACE) $\downarrow$	Grid 1 max ( $\times$ PACE) $\downarrow$	Grid 2 mean ( $\times$ PACE) $\downarrow$	Grid 2 max ( $\times$ PACE) $\downarrow$
ReAct	1.121 1.144 1.056	2.796 3.495 2.281	1.147 1.174 1.070	3.692 3.128 2.742
AutoRPA	2.107 1.942 2.715	11.997 9.660 19.314	2.168 2.006 2.805	16.034 12.927 26.538
ToolPro	1.121 1.144 1.056	2.796 3.495 2.281	1.147 1.174 1.070	3.692 3.128 2.742
PACE	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000

Table 2: Cost ratios relative to PACE over two grids of 300 conditions each. Mean is the mean of the ratios for individual conditions, and max is the largest tested condition mean. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Bold marks the best displayed values. Conditional 95% intervals are in Appendix C.7 .

Policy	Sepsis ( $\times$ PACE) $\downarrow$	BPI 2019 ( $\times$ PACE) $\downarrow$	Wiki tools ( $\times$ PACE) $\downarrow$	Wiki humans ( $\times$ PACE) $\downarrow$
ReAct	0.971 0.998 0.989	1.531 1.603 1.393	1.730 1.480 1.288	1.056 1.060 1.040
AutoRPA	1.145 1.123 1.246	1.582 1.641 1.489	1.754 1.498 1.331	1.164 1.144 1.232
ToolPro	0.971 0.998 0.989	1.531 1.603 1.393	1.730 1.480 1.288	1.056 1.060 1.040
PACE	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000

Table 3: Cost ratios relative to PACE on four recorded arrival sequences, using ten paired runs. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Bold marks the best displayed values. Conditional 95% intervals are in Appendix C.7 .

Variant	Grid 1 mean ( $\times$ PACE)	Grid 2 mean ( $\times$ PACE)	Logs mean ( $\times$ PACE)	Grid max ( $\times$ PACE)
PACE	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000
No savings test	1.174 1.186 1.181	1.140 1.167 1.121	1.581 1.548 1.451	1.957 1.810 1.901
No cost budget	1.008 1.014 1.007	1.015 1.016 1.010	1.000 1.000 1.000	1.371 1.410 1.301
Equal attempt costs	1.100 1.093 1.119	1.082 1.095 1.077	1.227 1.175 1.297	1.568 1.567 1.466
Eager retry	10.317 8.414 18.329	10.919 9.352 19.286	3.303 3.326 4.922	92.863 73.996 195.631

Table 4: Cost ratios after removing or simplifying PACE components. Values are mean cost ratios relative to PACE, which is exactly one. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Paired intervals are in Appendix C.8 . Grid max is the largest tested condition-mean ratio, without a sampling interval.

Appendix figures & tables15 assets

Supplementary material from the paper’s appendix.

Appendix

Family	$c$ (K tokens)	$c^{\mathrm{prog}}$ (K tokens)	$q$ (fraction)	Saving share (fraction)
Contacts	98.7 – 39.2	0.425 – 0.552	0.000 – 0.033	0.996 – 0.953
Markor delete	33.7 10.8 21.5	0.332 0.331 0.388	0.000 0.033 0.000	0.990 0.936 0.982
Calendar	314 – –	0.640 – –	0.000 – –	0.998 – –
OsmAnd marker	– – –	– – –	– – –	– – –
Calc table	– 647 –	– 0.677 –	– 0.000 –	– 0.999 –
Writer memo	70.2 50.7 37.0	0.596 0.692 0.724	0.000 0.000 0.000	0.992 0.986 0.980

Appendix

Table 5: Serving costs and estimated savings for the initial programs. Both cost columns use thousands of the tokens defined in Section 2 .

c

is the baseline-subtracted mean agent cost. Thirty deployment runs provide the mean extraction cost

c^{\mathrm{prog}}

and failure fraction

q

. The saving share charges one mean-cost agent fallback for a failed execution. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Appendix A.8 reports confidence intervals for the deployment estimates. A dash means an unavailable program-path value, and the Qwen web request was refused by the provider.

Family	Mean $c$ (K tokens)	Agent successes (of 30)	Program successes (of 30)	Saving share (fraction)
Contacts	67.1 – 42.2	30/30 – 30/30	30/30 – 29/30	0.994 – 0.954
Markor delete	35.4 22.3 19.3	30/30 23/30 30/30	30/30 29/30 30/30	0.991 0.952 0.980
Calendar	535.3 – –	14/30 – –	30/30 – –	0.999 – –
OsmAnd marker	– – –	– – –	– – –	– – –

Appendix

Table 6: Agent replay costs and success counts on thirty matched deployment bindings per populated entry.

c

is the mean baseline-subtracted cost in K tokens, with K=

10^{3}

. Saving share uses the mean-cost fallback estimate

qc

. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Appendix A.8 reports the confidence intervals.

Family	Verification outcomes	Given (of 5)	Extracted (of 5)
Contacts	P/P/P F/F/P P/G/P	0/5 – 5/5	0/5 – 5/5
Markor delete	P/P/P P/P/P P/P/P	5/5 5/5 5/5	5/5 5/5 5/5
Calendar	P/P/P F/G/F F/G/G	3/5 – –	3/5 – –
OsmAnd marker	F/F/F F/F/F –	– – –	– – –
Calc table	– – –	– – –	– – –
Writer memo	– – –	– – –	– – –

Appendix

Table 7: Repeated compilation outcomes. Each entry reports the initial attempt and two repeated attempts as P (passes verification), F (fails verification), or G (generation failure). Verification requires all three source tasks to pass, and tasks left untested after the first failed task are not counted as failures. Repeated attempts are not deployed. The given and extracted columns report the checks of the initial program in Appendix A.6 , which are not part of verification. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. The three compilation attempts share traces and translation, so no independent-trial confidence interval is assigned.

Family	$c^{\mathrm{prog}}$ (tokens)	Failures (of 30) 95% CI (fraction)
Contacts	424.5 $+14.2$ $-23.0$ – 552.1 $+39.6$ $-35.9$	0/30 $[0.000,$ $0.116]$ – 1/30 $[0.001,$ $0.172]$
Markor delete	331.6 $+5.1$ $-4.8$ 330.6 $+13.1$ $-13.2$ 388.1 $+25.4$ $-23.6$	0/30 $[0.000,$ $0.116]$ 1/30 $[0.001,$ $0.172]$ 0/30 $[0.000,$ $0.116]$
Calendar	640.0 $+42.8$ $-47.9$ – –	0/30 $[0.000,$ $0.116]$ – –
OsmAnd marker	– – –	– – –
Calc table	– 676.6 $+12.9$ $-13.1$ –	– 0/30 $[0.000,$ $0.116]$ –
Writer memo	596.3 $+52.9$ $-46.3$ 692.0 $+42.5$ $-42.8$ 724.1 $+55.7$ $-50.6$	0/30 $[0.000,$ $0.116]$ 0/30 $[0.000,$ $0.116]$ 0/30 $[0.000,$ $0.116]$

Appendix

Table 8: Confidence intervals for deployment estimates of the initial programs.

c^{\mathrm{prog}}

uses tokens and gives the mean followed by positive and negative offsets of its 95 percent binding-bootstrap interval. Failures shows an observed count followed by the lower and upper endpoints of a 95 percent Clopper–Pearson interval under an independent Bernoulli working model. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. These intervals condition on the recorded program and task-binding protocol. The exploration runs, which retry failed source tasks, and single compilation cost records do not support a cost interval based on independent trials.

Family	Mean $c$ (K tokens)	Agent CV (ratio)
Contacts	67.1 $+7.8$ $-7.8$ – 42.2 $+1.5$ $-1.4$	0.326 – 0.099
Markor delete	35.4 $+4.8$ $-4.5$ 22.3 $+9.4$ $-7.1$ 19.3 $+1.0$ $-.8$	0.373 1.042 0.128
Calendar	535.3 $+94.4$ $-89.3$ – –	0.485 – –
OsmAnd marker	– – –	– – –

Appendix

Table 9: Agent-cost estimates and confidence intervals for the matched replays in Table 6 . Each populated entry is the mean cost across thirty recorded bindings. The offsets below the mean give its 95 percent binding-bootstrap interval in K tokens. CV divides the sample standard deviation by the mean. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively.

Family	Agent successes (of 30) 95% CI (fraction)	Program successes (of 30) 95% CI (fraction)	Saving share (fraction)
Contacts	30/30 $[0.884,$ $1.000]$ – 30/30 $[0.884,$ $1.000]$	30/30 $[0.884,$ $1.000]$ – 29/30 $[0.828,$ $0.999]$	0.994 $+{<}.001$ $-{<}.001$ – 0.954 $+.034$ $-.067$
Markor delete	30/30 $[0.884,$ $1.000]$ 23/30 $[0.577,$ $0.901]$ 30/30 $[0.884,$ $1.000]$	30/30 $[0.884,$ $1.000]$ 29/30 $[0.828,$ $0.999]$ 30/30 $[0.884,$ $1.000]$	0.991 $+.001$ $-.001$ 0.952 $+.037$ $-.071$ 0.980 $+.002$ $-.002$
Calendar	14/30 $[0.283,$ $0.657]$ – –	30/30 $[0.884,$ $1.000]$ – –	0.999 $+{<}.001$ $-{<}.001$ – –
OsmAnd marker	– – –	– – –	– – –

Appendix

Table 10: Confidence intervals for success rates and saving shares on the matched replay bindings. Successes gives observed counts and 95 percent Clopper–Pearson endpoints under an independent Bernoulli working model. Saving share gives the mean with positive and negative 95 percent bootstrap offsets, resampling matched agent costs, program charges, and failure indicators together. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. The saving bootstrap cannot reveal a failure mode absent from the sample. An offset marked

<.001

is positive but smaller than

0.001

. For zero failures in thirty uses, the binomial failure interval is

[0,0.116]

even when the empirical saving interval is narrow.

Family	Given (of 5) 95% CI (fraction)	Extracted (of 5) 95% CI (fraction)
Contacts	0/5 $[0.000,$ $0.522]$ – 5/5 $[0.478,$ $1.000]$	0/5 $[0.000,$ $0.522]$ – 5/5 $[0.478,$ $1.000]$
Markor delete	5/5 $[0.478,$ $1.000]$ 5/5 $[0.478,$ $1.000]$ 5/5 $[0.478,$ $1.000]$	5/5 $[0.478,$ $1.000]$ 5/5 $[0.478,$ $1.000]$ 5/5 $[0.478,$ $1.000]$
Calendar	3/5 $[0.147,$ $0.947]$ – –	3/5 $[0.147,$ $0.947]$ – –
OsmAnd marker	– – –	– – –

Appendix

Table 11: Checks of the verified programs on five additional bindings, with 95 percent Clopper–Pearson intervals. Each cell shows the observed count and then the lower and upper endpoints under an independent Bernoulli working model. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Five checks provide limited evidence about future binding reliability. Verification and repair use their bindings adaptively and are reported as exact counts without test-set intervals.

Scenario $r$ : cost ratio	ReAct ( $\times$ PACE)	PACE ( $\times$ PACE)	Equal attempt costs ( $\times$ PACE)	Equal / PACE (all models)
$r=0.5$	1.280 $+.113$ $-.072$ 1.226 $+.068$ $-.060$ 1.066 $+.024$ $-.017$	1.000 1.000 1.000	0.998 $+.007$ $-.005$ 1.012 $+.011$ $-.009$ 1.027 $+.022$ $-.015$	1.012 $+.007$ $-.006$
$r=1$	1.322 $+.150$ $-.090$ 1.241 $+.091$ $-.076$ 1.131 $+.063$ $-.040$	1.000 1.000 1.000	1.000 1.005 $+.001$ $-.001$ 1.000	1.002 $+{<}.001$ $-{<}.001$
$r=2$	1.334 $+.179$ $-.098$ 1.241 $+.107$ $-.085$ 1.177 $+.086$ $-.056$	1.000 1.000 1.000	1.030 $+.011$ $-.009$ 1.032 $+.011$ $-.011$ 0.999 $+.020$ $-.022$	1.020 $+.010$ $-.009$
$r=5$	1.261 $+.151$ $-.085$ 1.210 $+.105$ $-.079$ 1.191 $+.085$ $-.060$	1.000 1.000 1.000	1.106 $+.031$ $-.027$ 1.174 $+.045$ $-.038$ 1.143 $+.055$ $-.050$	1.141 $+.034$ $-.030$
Cost-dependent $p$	1.601 $+.142$ $-.134$ 2.046 $+.153$ $-.160$ 1.783 $+.163$ $-.135$	1.000 1.000 1.000	1.141 $+.056$ $-.052$ 1.083 $+.022$ $-.018$ 1.144 $+.093$ $-.074$	1.123 $+.038$ $-.032$
Cost-dependent $p$ + costly frequent	0.958 $+.001$ $-.001$ 1.000 1.000	1.000 1.000 1.000	0.989 $+{<}.001$ $-{<}.001$ 1.100 $+.002$ $-.002$ 1.078 $+.002$ $-.002$	1.056 $+.001$ $-.002$

Appendix

Table 12: Sensitivity to missing costs and assigned cost dependencies. Each row uses twelve combinations of models and logs and ten paired runs. The ReAct, PACE, and Equal attempt costs columns show mean cost ratios to PACE for each model. The last column averages the Equal attempt costs-to-PACE ratios across all models. Nonzero-width 95 percent paired bootstrap intervals appear as upper and lower offsets below the mean; exact zero-width intervals are omitted. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. An offset marked

<.001

is positive but smaller than

0.001

. The listed

r=C^{\mathrm{fail}}/C

is a target ratio. The incomplete DeepSeek Web charge sets a recorded lower bound on its failed-attempt cost, which can raise the actual ratio. Both policies use the same

\epsilon=0.25

budget.

Policy	Grid 1 mean ( $\times$ PACE) $\downarrow$	Grid 1 max ( $\times$ PACE) $\downarrow$	Grid 2 mean ( $\times$ PACE) $\downarrow$	Grid 2 max ( $\times$ PACE) $\downarrow$
ReAct	1.121 $+.023$ $-.016$ 1.144 $+.014$ $-.015$ 1.056 $+.022$ $-.016$	2.796 3.495 2.281	1.147 $+.029$ $-.022$ 1.174 $+.024$ $-.021$ 1.070 $+.018$ $-.014$	3.692 3.128 2.742
AutoRPA	2.107 $+.022$ $-.006$ 1.942 $+.033$ $-.021$ 2.715 $+.051$ $-.044$	11.997 9.660 19.314	2.168 $+.031$ $-.015$ 2.006 $+.051$ $-.030$ 2.805 $+.045$ $-.034$	16.034 12.927 26.538
ToolPro	1.121 $+.023$ $-.016$ 1.144 $+.014$ $-.015$ 1.056 $+.022$ $-.016$	2.796 3.495 2.281	1.147 $+.029$ $-.022$ 1.174 $+.024$ $-.021$ 1.070 $+.018$ $-.014$	3.692 3.128 2.742
Eager + allowance	1.036 $+.005$ $-.004$ 1.070 $+.004$ $-.003$ 1.007 $+.002$ $-.003$	1.449 1.492 1.314	1.033 $+.004$ $-.003$ 1.093 $+.005$ $-.003$ 1.007 $+.003$ $-.003$	1.455 1.525 1.321
After 10 arrivals	1.032 $+.005$ $-.004$ 1.032 $+.004$ $-.004$ 1.007 $+.002$ $-.003$	1.449 1.492 1.314	1.029 $+.004$ $-.003$ 1.055 $+.005$ $-.003$ 1.007 $+.003$ $-.003$	1.455 1.525 1.321
After 10 successes	1.068 $+.008$ $-.006$ 1.083 $+.007$ $-.007$ 1.028 $+.006$ $-.004$	1.716 1.414 1.323	1.073 $+.007$ $-.005$ 1.113 $+.008$ $-.008$ 1.034 $+.008$ $-.007$	1.592 1.505 1.451

Appendix

Table 13: Cost across the two parameter grids, relative to PACE. Each grid contains one hundred conditions per model and eight paired runs per condition. Mean is the mean of the cost ratios for individual conditions, and Max is the largest tested condition mean. Nonzero-width 95 percent paired bootstrap intervals appear as upper and lower offsets below the mean; exact zero-width intervals are omitted. Intervals use 2000 shared bootstrap resamples of runs and condition on the tested scenarios and given profiles. An offset marked

<.001

is positive but smaller than

0.001

. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. AutoRPA and ToolPro are decision-rule adaptations defined in Appendix C.4 . Tables 2 and 3 show the rows for ReAct, AutoRPA, ToolPro, and PACE. PACE is exactly one by normalization; other fixed ratios also have zero-width intervals. The descriptive maxima have no sampling interval.

Policy	Sepsis ( $\times$ PACE) $\downarrow$	BPI 2019 ( $\times$ PACE) $\downarrow$	Wiki tools ( $\times$ PACE) $\downarrow$	Wiki humans ( $\times$ PACE) $\downarrow$
ReAct	0.971 $+.019$ $-.022$ 0.998 $+.046$ $-.048$ 0.989 $+.014$ $-.013$	1.531 $+.272$ $-.183$ 1.603 $+.299$ $-.222$ 1.393 $+.179$ $-.144$	1.730 $+.669$ $-.387$ 1.480 $+.428$ $-.247$ 1.288 $+.303$ $-.166$	1.056 $+.017$ $-.015$ 1.060 $+.016$ $-.016$ 1.040 $+.013$ $-.012$
AutoRPA	1.145 $+.033$ $-.029$ 1.123 $+.036$ $-.037$ 1.246 $+.045$ $-.041$	1.582 $+.278$ $-.190$ 1.641 $+.303$ $-.225$ 1.489 $+.181$ $-.146$	1.754 $+.676$ $-.392$ 1.498 $+.429$ $-.251$ 1.331 $+.317$ $-.172$	1.164 $+.017$ $-.015$ 1.144 $+.014$ $-.015$ 1.232 $+.016$ $-.014$
ToolPro	0.971 $+.019$ $-.022$ 0.998 $+.046$ $-.048$ 0.989 $+.014$ $-.013$	1.531 $+.272$ $-.183$ 1.603 $+.299$ $-.222$ 1.393 $+.179$ $-.144$	1.730 $+.669$ $-.387$ 1.480 $+.428$ $-.247$ 1.288 $+.303$ $-.166$	1.056 $+.017$ $-.015$ 1.060 $+.016$ $-.016$ 1.040 $+.013$ $-.012$
Eager + allowance	1.007 $+.007$ $-.006$ 1.027 $+.016$ $-.019$ 0.997 $+.001$ $-.001$	1.002 $+.003$ $-.002$ 0.995 $+.012$ $-.016$ 1.057 $+.072$ $-.056$	1.004 $+.009$ $-.006$ 0.997 $+.030$ $-.038$ 1.003 $+.005$ $-.006$	1.005 $+.002$ $-.002$ 1.021 $+.001$ $-.001$ 1.001 $+{<}.001$ $-.001$
After 10 arrivals	1.010 $+.007$ $-.006$ 1.010 $+.007$ $-.008$ 0.997 $+.001$ $-.001$	1.003 $+.004$ $-.003$ 0.988 $+.012$ $-.017$ 1.057 $+.072$ $-.056$	1.005 $+.009$ $-.006$ 0.994 $+.030$ $-.038$ 1.003 $+.005$ $-.006$	1.006 $+.002$ $-.002$ 1.008 $+.010$ $-.005$ 1.001 $+{<}.001$ $-.001$
After 10 successes	1.007 $+.009$ $-.009$ 1.011 $+.016$ $-.016$ 1.003 $+.007$ $-.006$	1.123 $+.053$ $-.040$ 1.131 $+.061$ $-.052$ 1.147 $+.107$ $-.068$	1.241 $+.235$ $-.139$ 1.128 $+.098$ $-.070$ 1.068 $+.057$ $-.032$	1.024 $+.004$ $-.004$ 1.025 $+.009$ $-.007$ 1.015 $+.005$ $-.004$

Appendix

Table 14: Cost on four recorded arrival sequences, relative to PACE. Each value divides the policy’s mean cost by PACE’s mean cost in the same condition, using ten paired runs. Nonzero-width 95 percent paired bootstrap intervals appear as upper and lower offsets below the mean; exact zero-width intervals are omitted. Intervals use 2000 shared bootstrap resamples of runs and condition on the tested scenarios and given profiles. An offset marked

<.001

is positive but smaller than

0.001

Variant	Grid 1 mean ( $\times$ PACE)	Grid 2 mean ( $\times$ PACE)	Logs mean ( $\times$ PACE)	Grid max ( $\times$ PACE)
PACE	1.000 1.000 1.000	1.000 1.000 1.000	1.000 1.000 1.000	1.000
No savings test	1.174 $+.011$ $-.011$ 1.186 $+.014$ $-.010$ 1.181 $+.017$ $-.011$	1.140 $+.012$ $-.007$ 1.167 $+.012$ $-.009$ 1.121 $+.014$ $-.009$	1.581 $+.149$ $-.087$ 1.548 $+.086$ $-.064$ 1.451 $+.092$ $-.068$	1.957
No cost budget	1.008 $+{<}.001$ $-{<}.001$ 1.014 $+.001$ $-.001$ 1.007 $+.001$ $-.002$	1.015 $+.001$ $-{<}.001$ 1.016 $+{<}.001$ $-{<}.001$ 1.010 $+.002$ $-.001$	1.000 $+{<}.001$ $-{<}.001$ 1.000 $+{<}.001$ $-{<}.001$ 1.000 $+{<}.001$ $-{<}.001$	1.410
Equal attempt costs	1.100 $+.009$ $-.006$ 1.093 $+.008$ $-.006$ 1.119 $+.010$ $-.006$	1.082 $+.004$ $-.002$ 1.095 $+.010$ $-.005$ 1.077 $+.010$ $-.006$	1.227 $+.041$ $-.032$ 1.175 $+.067$ $-.059$ 1.297 $+.056$ $-.055$	1.568
Eager retry	10.317 $+.481$ $-.262$ 8.414 $+.745$ $-.301$ 18.329 $+.659$ $-.458$	10.919 $+.555$ $-.532$ 9.352 $+.614$ $-.341$ 19.286 $+.694$ $-.467$	3.303 $+.490$ $-.437$ 3.326 $+.566$ $-.524$ 4.922 $+.587$ $-.576$	195.631

Appendix

Table 15: Cost ratios for the component ablations, relative to PACE. The first three columns show the mean of the cost ratios to PACE computed separately for each condition, with positive and negative offsets of the 95 percent paired bootstrap interval. Grid max is the largest tested condition mean across both grids and all three models. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. An offset marked

<.001

is positive but smaller than

0.001

. Equal attempt costs assumes

C^{\mathrm{fail}}=C

when estimating compilation cost, while keeping actual charges and reservations unchanged. No cost budget removes reservations and budget-triggered program list clearing.

Variant	Grid 1 $\Delta$ cost (%)	Grid 2 $\Delta$ cost (%)	Logs $\Delta$ cost (%)	Grid max ( $\times$ PACE)
PACE	0.0 0.0 0.0	0.0 0.0 0.0	0.0 0.0 0.0	1.000 1.000 1.000
No savings test	17.4 $+1.1$ $-1.1$ 18.6 $+1.4$ $-1.0$ 18.1 $+1.7$ $-1.1$	14.0 $+1.2$ $-.7$ 16.7 $+1.2$ $-.9$ 12.1 $+1.4$ $-.9$	58.1 $+14.9$ $-8.7$ 54.8 $+8.6$ $-6.4$ 45.1 $+9.2$ $-6.8$	1.957 1.810 1.901
No cost budget	0.8 $+{<}.1$ $-{<}.1$ 1.4 $+.1$ $-.1$ 0.7 $+.1$ $-.2$	1.5 $+.1$ $-{<}.1$ 1.6 $+{<}.1$ $-{<}.1$ 1.0 $+.2$ $-.1$	0.016 $+.080$ $-.044$ -0.013 $+.010$ $-.015$ 0.002 $+.016$ $-.013$	1.371 1.410 1.301
Equal attempt costs	10.0 $+.9$ $-.6$ 9.3 $+.8$ $-.6$ 11.9 $+1.0$ $-.6$	8.2 $+.4$ $-.2$ 9.5 $+1.0$ $-.5$ 7.7 $+1.0$ $-.6$	22.7 $+4.1$ $-3.2$ 17.5 $+6.7$ $-5.9$ 29.7 $+5.6$ $-5.5$	1.568 1.567 1.466
Eager retry	931.7 $+48.1$ $-26.2$ 741.4 $+74.5$ $-30.1$ 1732.9 $+65.9$ $-45.8$	991.9 $+55.5$ $-53.2$ 835.2 $+61.4$ $-34.1$ 1828.6 $+69.4$ $-46.7$	230.3 $+49.0$ $-43.7$ 232.6 $+56.6$ $-52.4$ 392.2 $+58.7$ $-57.6$	92.863 73.996 195.631

Appendix

Table 16: Cost change after removing or simplifying PACE components.

\Delta

is the mean percentage cost change from full PACE across conditions. Positive values mean higher cost. Blue, amber, and green identify GLM, DeepSeek, and Qwen, respectively. Offsets show the conditional 95 percent paired interval in percentage points; exact zero-width intervals are omitted. Grid max is the largest tested condition-mean ratio, without a sampling interval.

Serving path	Success (of 12)	Interrupted (count)	Mean cost bounds (milli-USD)
Agent	7/12	4	[8.142, 21.590]
Program + fallback	11/12	1	[1.202, 4.564]

Appendix

Table 17: Observed outcomes and serving costs for twelve paired Calendar tasks. Mean cost bounds are in milli-USD and include extraction and any fallback. Their endpoints combine known charges with the saved reservations for unconfirmed costs; they are not confidence intervals. Interrupted runs remain unsuccessful outcomes, and the agent has one additional step-limit failure. Serving costs exclude the compilation of the fixed program and the separate compilation attempt.

Seed	Condition	Agent	P+F	Agent cost (milli-USD)	P+F cost (milli-USD)	Fields (of 6)
0	Clean	Interrupted	Success	[5.147, 45.493]	0.048	–
0	Renamed submit	Interrupted	Success	[2.050, 42.396]	0.763	6/6
0	Blocking dialog	Step limit	Success	17.156	1.255	6/6
1	Clean	Success	Success	9.687	0.048	–
1	Renamed submit	Success	Success	6.831	0.763	6/6
1	Blocking dialog	Success	Success	11.091	1.129	6/6

Appendix

Table 18: All paired tasks specified in advance, including provider interruptions and unsuccessful execution. Costs use milli-USD. Bracketed values give lower and upper accounting bounds, and costs shown without brackets are confirmed. P+F means program execution followed by agent fallback on an execution error. Fields counts the six target values already correct when fallback begins. All pairs start from matching application and interface states.

Arrival	Condition	Outcome	Cost (milli-USD)	Prefix ceiling (milli-USD)	Prefix total (milli-USD)
1	Renamed submit	Denied	0.000	25.000	0.000
2	Blocking dialog	Success	1.257	50.000	1.257
3	Renamed submit	Success	0.890	75.000	2.147
4	Blocking dialog	Interrupted	[0.215, 40.561]	100.000	42.708

Appendix

Table 19: Four tight-budget tests in their arrival order set in advance. Costs and prefix totals use milli-USD. The reference increases by 20 milli-USD per scheduled arrival, including a denied arrival. The prefix total includes charges and saved reservations for unsettled calls. The first task is denied before any model call or GUI service, so this test does not satisfy the theorem’s assumption that default service costs at most its reference charge.

Computer-Use Agents

Computer-use agents perceive and operate graphical interfaces and software tools to complete tasks across websites, apps, and desktops.

See all 160 papers

Aug 6, 2026

Activity Frames: Deterministic Screen-Activity Compilation for Agent Memory and Replay

Computer-use agents pay full frontier inference to re-derive routines their user has already performed, because an agent's memory today records what the user said, not what the user did. We compile passively captured screen activity into agent memory with a deterministic, zero-model pipeline: it segments a local capture stream into typed activity frames, bounded episodes carrying application, site, timing, input volume, and evidence pointers back to the raw rows, with no model in the loop, so the output is byte-identical, cacheable, and mechanically auditable. On one professional's single-user corpus of 128,756 frames over 51 active days, the compiler reduces a day of raw capture to a prompt-ready context block 86x smaller in 68 ms, and an agent reading that block answers questions about the day at 98.4% accuracy (Wilson 95% CI 91.7-99.7%) against an independent oracle, versus 66-80% for an LLM summary of the same capture, a mid-tier model reading the block matching a frontier one. The same compiler doubles as a demand-side cost instrument. Read off passive, pre-delegation human activity rather than agent rollouts, it supplies two parameters that agent-cost models assume but, to our knowledge, have not measured: the Routine Overhead Ratio R and the routine recurrence h. We report first values of R, a modeled upper bound, at 60-343x, and a delegable recurrence of 9.0% in-sample and 7.7% out-of-sample, for a realistic all-fleet token ceiling near 8%; a compiled routine replays deterministically with the model out of the loop, demonstrated live at zero model tokens on a guard-matched hit. Schema, compiler, and evaluation harness are open.

Nossa Iyamu

Independent Researcher

Computer-Use Agents LLM Agent Memory Cost-Aware Inference

Ask PDF

May 20, 2026

Agent JIT Compilation for Latency-Optimizing Web Agent Planning and Scheduling

Computer-use agents (CUAs) automate tasks specified with natural language such as "order the cheapest item from Taco Bell" by generating sequences of calls to tools such as click, type, and scroll on a browser. Current implementations follow a sequential fetch-screenshot-execute loop where each iteration requires an LLM call, resulting in high latency and frequent errors from incorrect tool use. We present agent just-in-time (JIT) compilation, a system that compiles task descriptions directly into executable code that may include LLM calls, tool calls, and parallelization. Our approach comprises three components: (1) JIT-Planner, which generates multiple code plans, validates each against tool specifications, and selects the minimum-cost candidate; (2) JIT-Scheduler, which explores parallelization strategies via Monte Carlo cost estimation from learned latency distributions; and (3) an invariant-enforcing tool protocol specifying precondition and postcondition requirements to reduce the rate of incorrect tool use. Across five applications, JIT-Planner achieves

10.4\times

speedup and 28

\%

higher accuracy over Browser-Use, while JIT-Scheduler achieves

2.4\times

speedup and 9% higher accuracy over OpenAI CUA.

Caleb Winston, Ron Yifeng Wang, Azalia Mirhoseini +1

Stanford University, Stanford, CA, USA.

Computer-Use Agents LLM Agent Orchestration LLM Agent Workflow Optimization LLM Agent Planning LLM Agent Reliability

Ask PDF

Jun 16, 2026

PreAct: Computer-Using Agents that Get Faster on Repeated Tasks

Computer-using agents drive real software through the screen -- clicking and typing -- but they solve every task from scratch: asked to repeat a task, an agent re-reads the screen, re-reasons every tap, and pays the full cost again. We present PreAct, which lets such an agent get faster on tasks it has done before. The first time it succeeds, PreAct compiles the run into a small state-machine program-states that check the screen, transitions that act-and on later runs replays it directly instead of invoking the agent 8.5-13x faster, with no per-step language-model calls. Replay is not blind: at each step PreAct checks that the screen matches what the program expects before acting, and hands control back to the agent the moment something is off. PreAct applies the same discipline when deciding what to keep: a freshly compiled program enters the store only if, re-run from a clean state, an independent evaluator confirms it solved the task-catching programs that replay to their last step yet leave the task undone. Across a mobile, a desktop, and a web benchmark, this store-time check separates repeated runs that improve from ones that degrade as faulty programs accumulate, worth 1.75-2.6 tasks per benchmark, the same direction on all three; a fallback that explores afresh when no program fits brings PreAct level with a strong record-and-replay baseline. We also report what did not matter: prompt wording, runtime guardrails, and whether a language model or a plain embedding retriever selects which program to reuse.

Bojie Li

Pine AI

Computer-Use Agents LLM Agent Skill Learning Replay-Based Continual Learning

Ask PDF

Abstract

Computer-Use Agents

Explore similar work

Activity Frames: Deterministic Screen-Activity Compilation for Agent Memory and Replay

Agent JIT Compilation for Latency-Optimizing Web Agent Planning and Scheduling

PreAct: Computer-Using Agents that Get Faster on Repeated Tasks