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.

Computer-use agents can now carry out meaningful tasks on the web by looking at the screen and clicking, typing, and scrolling, one step at a time. But because the model has to stop and think before every single click, these assistants are slow and often make mistakes, like clicking the wrong button. We take a different approach, borrowed from how programming languages work. First, instead of deciding each step on the fly, our system reads the whole task up front and writes a short program to carry it out, choosing the version that should run fastest and checking it for errors before it runs. Second, it decides how to execute that program: some tasks finish quickest by going one step at a time, others by doing independent parts simultaneously, and others by attempting the same step several ways at once and keeping whichever finishes first. The right execution strategy is hard to guess in advance, so our system estimates the likely time of each and chooses automatically. Across five applications, this made the assistants about ten times faster and substantially more accurate, a step toward agents that are both quicker and more reliable.