On the Clock: Towards Punctual and Productive Time-Budgeted AI Agents

Aaron Wang; Neelabh Madan; Vlad Sobal; Matthew Trager; Michael Kleinman; Elman Mansimov; Wei Xia; Stefano Soatto

cs.AIOct 7, 2026

On the Clock: Towards Punctual and Productive Time-Budgeted AI Agents

Authors: Aaron Wang, Neelabh Madan, Vlad Sobal, Matthew Trager, Michael Kleinman, Elman Mansimov, Wei Xia, Stefano Soatto

Organizations: University of Illinois at Chicago · AWS Agentic AI · New York University · AWS

Abstract

We study whether small LLM agents can operate effectively under explicit wall-clock time budgets by both respecting the allocated runtime and using available time productively. We evaluate Qwen3.6-27B on five competitions from MLE-Bench Lite and Qwen3-4B on Zork I (Jericho), two agentic benchmarks where additional computational time can meaningfully improve performance. In the simplest setting, where the budget is stated only in the prompt, agents fail to translate the stated budget into controlled use of time. These failures arise from gaps in time awareness, since the harness provides no timing feedback, but also because they cannot reliably anticipate the duration of actions, and do not have a learned mapping from available time to an appropriate strategy. We investigate two complementary classes of interventions: harness-based mechanisms that expose timing information and enforce deadlines, and reinforcement learning with budget-aware rewards. Injecting timing information through the harness substantially improves budget adherence for Qwen3.6-27B without measurable loss in performance, while enforcement hooks tighten adherence further. RL with GRPO achieves near-perfect budget adherence on Zork I and generalizes to held-out budgets not seen during training, but does not improve task performance over the untrained harness on MLE-Bench. Once agents are made to respect the budget, they still fail to use additional time to improve task performance. RL-trained policies learn when to stop but often fill extra time with repeated actions, and GRPO training on multiple budgets tends to collapse toward the strategy learned for the shortest budget. Our results reveal a gap between time adherence and productive time allocation, which remains a central challenge for budget-conditioned agents.

Figures & tables

Figure 1 : (Left two) Mean quality (leaderboard percentile) against mean wall-clock time used by Qwen3.6-27B on MLE-Bench, with the budget stated in the prompt (left) and with the enforcement harness added (right). Color gives the stated budget and dashed lines mark the budget values. (Right two) Mid-episode time estimation on 15-minute MLE-Bench tasks. The agent is asked how long it has been working and how long the run will take in total, and its answer is plotted against the true value, with the dashed diagonal marking a perfect estimate. Open markers have a clock in context, filled markers do not.

Model	Budget	On time	Elapsed	Quality
Qwen3.6-27B	8 min	$35\%$	$12.9$ $\pm 12.6$	$50.3\pm 2.9$
	15 min	$83\%$	$\phantom{0}9.7$ $\pm 10.6$	$43.1\pm 8.6$
	60 min	$100\%$	$10.5$ $\pm 6.3$	$54.8\pm 7.2$
	none	–	$12.2$ $\pm 11.4$	$53.5\pm 7.8$

Table 1: Experiments on the Dog Breed Identification Task MLE-Bench Lite Task, budget stated in the prompt only. Qwen3.6-27B runs

8

–

13

min regardless of the prompt. On time is the fraction of runs finishing within the stated limit; elapsed is minutes, mean

\pm s.d.

; quality is leaderboard percentile over valid submissions, mean

\pm

s.e.m.

Condition	On budget (%)	Quality (%ile)	Turns	Time (s)	Valid (%)
Prompt only	15	$49.4\pm 4.4$	$22.4\pm 10.1$	$1453\pm 454$	78
+ Harness (clocks)	62	$42.1\pm 1.8$	$16.5\pm 6.4$	$897\pm 202$	88
+ Enforcement (clamp)	74	$46.8\pm 1.8$	$17.0\pm 6.5$	$847\pm 165$	90
+ Enforcement (refuse)	88	$42.4\pm 1.9$	$20.3\pm 8.0$	$812\pm 160$	78
+ RL (GRPO, refuse)	86	–	$18.9\pm 3.7$	$807\pm 37$	74

Table 2: MLE-Bench results . We show incremental effects of in-context clocks, budget enforcement, and RL at a fixed 15-minute budget (900 seconds), all conditions sharing an identical prompt (RL row explained in Section 4.3 ). On budget is the fraction of runs finishing within the stated limit; quality is leaderboard percentile over submissions that are both valid and on budget, mean

\pm

s.e.m.; turns and time are mean

\pm

s.d. Pooled over five MLE-bench competitions.

Figure 2 : Zork1 performance and time expenditure for Qwen3-4B with thinking mode disabled under per-episode time budgets, in four fixed-weight prompting conditions and two policies trained for 400 GRPO steps against the budget (

n=16

episodes per cell; episodes are terminated at

2\times

the budget, which serves as a hard cutoff). (a) Mean score against budget: the trained policies attain 46.4 and 16.6 points at 16 s, whereas no fixed-weight condition exceeds 0.6 points at any budget. (b) Elapsed time for the same episodes at budgets of 1, 4, and 16 s, with one marker per episode and horizontal jitter; dashed gray denotes the budget and dashed red the

2\times

budget hard cutoff. Stating the budget in the prompt alone does not meaningfully improve adherence, while AutoClock is the most effective harness-based intervention. RL yields the strongest overall performance, achieving both the best budget adherence and substantially higher task scores.

Hook	When it fires	What it does
Per-tool clock	After every tool call	Adds the time remaining to the result the agent reads
Periodic reminder	On a fixed time interval	Reports the time remaining even while a command is still running
Generation accounting	After every tool call	Reports how long the model spent generating text before the action
Enforcement (clamp)	Before a shell command runs	Shortens the command’s time limit so it stops by the deadline; the command still runs, but is cut off
Enforcement (refuse)	Before a shell command runs	Blocks the command and returns a message explaining why, so the agent must choose something cheaper

Table 3: Harness hooks. The first three only add information to what the agent reads. The two enforcement modes change the action itself and are never used together.

Panel of Figure 3 — Figure 3 : Mixed-budget GRPO training on Zork I with the step-wise time-shaped reward and the per-turn clock shown in the prompt ( $\lambda=0.1$ ).

Condition	Budget in	Per-turn	Callable	System prompt
	prompt	clock	clock	at $B{=}16$ s
No Budget	–	–	–	1301
Budget in Prompt	yes	–	–	1456
Clock Tool	yes	–	yes	1766
Clock Tool++	yes	–	yes	3013
Auto-Clock	yes	yes	–	1456

Table 4: The clock conditions. Per-turn clock appends [time used:

x

s of

B

s budget] to every observation; callable clock lets the model spend a turn on ACTION: time_elapsed to obtain the same string. Clock Tool and Clock Tool++ expose the identical tool and return the identical reply, and differ only in how it is documented. Budget in Prompt and Auto-Clock send the identical system prompt and differ only in the user turns. The last column is the system-prompt length in characters.

Algorithm	GRPO ( adv_estimator=grpo ), KL loss on, kl_loss_coef $=0.001$
Policy	Qwen3-4B, trained from the base model (no warm start)
Learning rate	$1\times 10^{-6}$
Batching	train batch $16$ , PPO mini-batch $16$ , micro-batch $1$ per GPU,
	gradient checkpointing on
Group size	$n=8$ rollouts per prompt $\Rightarrow 128$ episodes per step
Sampling	temperature $1.0$ , thinking disabled

Table 5: GRPO configuration, identical across runs

Qwen3-4B
	Elapsed Time (s)						Score (max = 350)
Budget (s) $\rightarrow$	0.5	1	2	4	8	16	0.5	1	2	4	8	16
Budget in Prompt	$1.1{\scriptstyle\pm 0.0}$	$2.1{\scriptstyle\pm 0.1}$	$4.1{\scriptstyle\pm 0.1}$	$7.4{\scriptstyle\pm 2.0}$	$15.8{\scriptstyle\pm 1.0}$	$21.2{\scriptstyle\pm 13.1}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$	$0.3{\scriptstyle\pm 1.2}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$
+ Clock Tool	$1.1{\scriptstyle\pm 0.0}$	$2.1{\scriptstyle\pm 0.1}$	$4.0{\scriptstyle\pm 0.2}$	$7.9{\scriptstyle\pm 0.8}$	$15.1{\scriptstyle\pm 2.8}$	$27.7{\scriptstyle\pm 10.3}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$	$0.6{\scriptstyle\pm 2.5}$	$0.0{\scriptstyle\pm 0.0}$	$0.3{\scriptstyle\pm 1.2}$	$0.3{\scriptstyle\pm 1.2}$
+ Clock Tool++	$1.1{\scriptstyle\pm 0.1}$	$2.1{\scriptstyle\pm 0.1}$	$3.1{\scriptstyle\pm 0.7}$	$5.4{\scriptstyle\pm 2.1}$	$11.5{\scriptstyle\pm 4.4}$	${\color[rgb]{0.1211,0.3047,0.4727}\mathbf{16.1{\scriptstyle\pm 13.3}}}$	$0.0{\scriptstyle\pm 0.0}$	$0.6{\scriptstyle\pm 2.5}$	$0.3{\scriptstyle\pm 1.2}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$	$0.3{\scriptstyle\pm 1.2}$
+ Auto-Clock	$1.1{\scriptstyle\pm 0.1}$	$1.4{\scriptstyle\pm 0.3}$	${\color[rgb]{0.1211,0.3047,0.4727}\mathbf{2.3{\scriptstyle\pm 0.3}}}$	${\color[rgb]{0.1211,0.3047,0.4727}\mathbf{3.6{\scriptstyle\pm 1.1}}}$	${\color[rgb]{0.1211,0.3047,0.4727}\mathbf{8.2{\scriptstyle\pm 2.2}}}$	${\color[rgb]{0.1211,0.3047,0.4727}\mathbf{14.2{\scriptstyle\pm 4.0}}}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$	$0.3{\scriptstyle\pm 1.2}$	$0.0{\scriptstyle\pm 0.0}$	$0.0{\scriptstyle\pm 0.0}$

Table 6: Elapsed time and raw Zork1 score under different time budgets with thinking disabled. The left block reports elapsed time in seconds, while the right block reports task score. Values are mean

\pm

standard deviation over

n=16

episodes. Elapsed-time entries whose mean is within 15% of the stated budget are shown in bold . All prompting conditions use the same stated budget and cutoff (

2\times

budget), differing only in how clock information is communicated. The Qwen3-4B GRPO rows use time-budget RL trained for 400 steps.

Reward	On-target (%)	Score (of 350)	Median $t/B$	Steps to score $\geq 10$
linear	100.0	8.7	1.00	–
gaussian	99.7	20.8	1.00	89
step_wise	96.1	22.5	1.00	56

Table 7: Comparison of shaped reward formulations for time-budgeted RL on Zork1 . All three rewards achieve strong budget adherence, with median elapsed time matching the specified budget. Among them, step_wise achieves the highest task score and reaches a score of at least 10 substantially earlier in training than gaussian .

setting	model	0.5 s	1 s	2 s	4 s	8 s	16 s
thinking off
Clock Tool	Qwen3-4B	0.00	0.00	0.19	0.00	0.81	0.00
Clock Tool	Qwen3.5-9B	0.00	0.00	0.00	0.00	0.00	0.00
Clock Tool	Qwen3.8-27B	0.25	0.19	0.25	0.12	0.06	0.38
Clock Tool++	Qwen3-4B	0.19	0.81	1.75	2.06	2.75	3.12
Clock Tool++	Qwen3.5-9B	0.88	0.50	0.50	0.19	0.31	1.00

Table 8: Clock-tool usage with thinking disabled. Each cell is the mean number of ACTION: time_elapsed calls per episode over 16 episodes of zork1 . Clock Tool and Clock Tool++ expose the same clock tool and differ only in how the tool is documented in the system prompt.

		Mean signed error $\pm s.d.$ (s)
Model	Clock	Elapsed	Budget left	Time to finish	Total runtime
Qwen3.6-27B	no	$-69$ $\pm 110$	$+43$ $\pm 381$	$-25$ $\pm 366$	$-735$ $\pm 546$
Qwen3.6-27B	yes	$+46$ $\pm 187$	$-19$ $\pm 58$	$-53$ $\pm 214$	$-554$ $\pm 538$

Table 9: Mid-episode time-estimation probes on MLE-Bench (15-minute budget), the data behind Figure 1 (right). The agent is asked how much time has elapsed, how much budget remains, how much longer it will run, and what the total run duration will be. Errors are prediction minus ground truth in seconds. Qwen3.6-27B is probed by truncating its own recorded episodes, with the clock condition set by keeping or stripping the harness timer notices (

n{=}9

–

20

per cell;

54

–

67

80

probes parsed, the rest ignored the question and kept emitting tool calls). With a clock in context both models read elapsed time and remaining budget accurately. Without one, even elapsed time is off by more than a minute on average. Forecasting the run is hard in every condition, and Qwen3.6-27B underestimates its total runtime by roughly ten minutes with or without the clock. Reading the clock does not imply anticipating how long work will take.

Reward	Shape	Behaviour
Unshaped
$R=s$		Flat in $t$ , just the game score as reward
Cutoff
$R=s\cdot\mathbf{1}[\,t\leq B\,]$		Meet the deadline or forfeit the score. Finishing much earlier than the budget receives the same reward as finishing exactly at the budget.
Linear
$R=s+\lambda\max\!\left(0,\,1-\dfrac{\|t-B\|}{B}\right)$		The time bonus rises linearly to its maximum at $t=B$ and then decreases linearly, reaching zero at $t=2B$ .

Table 10: Time-shaped rewards for Zork I. Here

s\in[0,1]

is the normalized game score,

t

is the episode wall-clock time,

B

is the time budget, and

\lambda=0.1

controls the weight of the time bonus. For the Gaussian reward,

\sigma=10\,\mathrm{s}

Figure 4 : Time and quality distributions on MLE-Bench under the harness (clocks and enforcement), without RL training. Top panel shows elapsed-time density per budget. Bottom panel shows leaderboard percentile against elapsed time for valid submissions. Dotted vertical lines mark each stated budget. The agent scales time to the budget, but quality does not improve with additional time.

Symbol	Meaning	Steps 1–105	Steps 106–182
$q$	quality term	$1/(1+L)$	band, $c_{q}=3.0$
$c_{\mathrm{sub}}$	bonus for a gradeable file	$0.25$	$0.25$
$c_{\mathrm{time}}$	bonus for finishing on budget	$1.0$	$0.5$
$s$	on-budget speed slope	$0.5$	$0.15$
$\kappa$	share of $Q$ kept when late	$0.3$	$0.8$
$p_{\max}$	maximum late penalty	$1.35$	$1.35$

Table 11: Reward constants for the MLE-Bench GRPO run. The run launched with the left column and the compressive quality map

1/(1+L)

; the band and the right column replaced them at step

106

, after the kill moved to

B+30

s and lateness no longer had to be priced. The RL row of Table 2 is from the second phase.

Algorithm	GRPO, KL loss on (low-variance estimator), coefficient $0.001$
Policy	Qwen3.6-27B, trained from the released weights
Learning rate	$1\times 10^{-6}$ , constant; weight decay $0.1$
Group size	$21$ episodes per (competition, budget); $20$ groups per step
Response length	$\leq 16{,}384$ tokens per generation
Parallelism	tensor parallel $4$ , pipeline parallel $2$
Checkpoints	every $25$ steps

Table 12: GRPO configuration for MLE-Bench.

Explore similar work

May 29, 2026cs.LG

BAGEN: Are LLM Agents Budget-Aware?

While agents are increasingly spending more resources, today agent cost is mostly measured only after execution. A Budget-Aware Agent (BAGEN) should treat budget as an active control signal, rather than a passive cost metric. We first systematically define budget estimation as internal budgets (from agent computation) and external budgets (from agent actions). We then formalize budget-awareness as progressive interval estimation: at each step of a plan, an agent should predict an upper and lower bound on remaining budget, and alert when completion is unlikely. Scoring with a rollout-replay protocol, we find consistent failure patterns on four environments and five frontier agents: (1) strong agents do not necessarily have strong budget-awareness, with correlation r=0.35. (2) frontier models are consistently over-optimistic, continue spending on tasks that are unlikely to succeed, instead of alerting the user early. (3) budget-aware signal is actionable and trainable. Early stop saves 28-64% tokens on failed trajectories, and SFT+RL strengthens early stop and alert behavior. (4) precise interval calibration remains challenging, with interval coverage capping at 47% after SFT+RL. Project page: https://ragen-ai.github.io/bagen/

Yuxiang Lin, Zihan Wang, Mengyang Liu +9

1Northwestern University · 2O2 Lab · 3Independent +5

LLM Agent Evaluation AI Agent Benchmarks LLM Agents LLM Agent Training

Ask PDF

Oct 7, 2026cs.AI

AgentTime: Can Agents Estimate and Control Their Own Runtime?

An essential control of AI agents is their ability to manage runtime. This ability requires a sense of time-awareness, to predict and estimate wall-clock time and to control their own actions. Prior work has focused on time-awareness, but duration-following and control in native agent harnesses remain unexplored. We present AgentTime, a benchmark for testing whether agents can work for a requested duration, predict their runtime, and estimate elapsed time afterward. It comprises 222 tasks from 18 sources spanning coding, computer use, agentic work, and automated research. Duration-following experiments append a single instruction specifying how long to work, with requests ranging from about a minute to multiple days. Accuracy on these instructions varies substantially: Fable 5.1 in Claude Code deviates from requested runtimes by a typical factor of 2.9

\times

, compared with only 1.2

\times

for GPT-6 Astra in Codex. However, matching the requested runtime does not, by itself, establish continued work on the task. Among 158 reviewed Astra runs with classifiable transcripts, 14 explicitly slept after appearing to finish. In forecasting experiments, predictions tend to overestimate natural runtimes. In retrospective experiments, removing temporal information more than doubles deviation for Sol and Astra and nearly doubles it for Fable. An agent's ability to complete a task does not guarantee that it can control its own time or work for the whole requested duration. For agents to run reliably, safely, and autonomously over long horizons, we require the evaluation of both.

Michael Ofengenden, Maksym Andriushchenko

MATS · ELLIS Institute Tübingen, Max Planck Institute for Intelligent Systems, Tübingen AI Center

AI Agent Benchmarks Long-Horizon Agent Evaluation

Ask PDF

May 19, 2026cs.LG

ZEBRA: Zero-shot Budgeted Resource Allocation for LLM Orchestration

As autonomous agents increasingly execute end-to-end tasks under fixed monetary budgets, the pressing open question shifts from whether the budget is respected, to how to spend it effectively. Existing budget-aware methods typically control reasoning step-by-step within a single agent, or learn resource allocation policies via RL. None address how to split a budget across the composing phases of a multi-agent pipeline at inference time. We propose ZEBRA, a zero-shot framework that reduces multi-phase budget allocation to a continuous nonlinear knapsack problem: an LLM controller estimates per-phase utility curves, and a water-filling search on the Lagrange multiplier returns the per-phase split. Additive and multiplicative aggregations are unified under the same solver. On a

150

-task APPS coding benchmark, both ZEBRA variants outperform LLM-direct (budget allocation directly by an LLM) on every aggregate metric. At a budget of

α= 0.5

of the unconstrained spend, ZEBRA recovers

94.4\%

of unconstrained quality, versus

88.1\%

for LLM-direct. The advantage is statistically significant and transfers beyond coding: on a

3

-phase HotpotQA pipeline, ZEBRA beats LLM-direct by

14.3

pp, with allocations empirically robust to curve-estimation noise. On HotpotQA, ZEBRA arrives at a different budget split (near-balanced) compared to the APPS one (skewed towards a refinement phase), showing adaptation to the pipeline structure. More broadly, we show that lightweight algorithmic guidance at inference time can improve the economic behavior of autonomous multi-agent systems.

May Hamri, Inbal Talgam-Cohen

1Tel Aviv University

LLM Agent Orchestration Cost-Aware Inference LLM Agent Workflow Optimization Multi-Agent Systems

Ask PDF