Speculative Actions: A Lossless Framework for Faster AI Agents
Authors: Naimeng Ye
Arnav Ahuja
Georgios Liargkovas
Yunan Lu
Kostis Kaffes
Tianyi Peng
Venue: ICLR 2026 Oral (2026)
Keywords: AI Agents
Speculative Decoding
Parallel Execution
Agentic Serving
Agentic Simulation
Primary area: infrastructure, software libraries, hardware, systems, etc.
TL;DR: We introduce speculative actions—a lossless framework that predicts likely actions using faster models, enabling multiple API calls to be executed in parallel and thus yields substantial acceleration.

Abstract: AI agents are increasingly deployed in complex, interactive environments, yet their runtime remains a major bottleneck for training, evaluation, and real-world use. Typical agent behavior unfolds sequentially, where each action requires an API call that can incur substantial latency. For example, a game of chess between two state-of-the-art agents can take hours. We introduce speculative actions, a lossless acceleration framework for general agentic systems. Inspired by speculative execution in microprocessors and speculative decoding in LLM inference, our method uses faster models to predict likely future actions and executes them in parallel, committing only when predictions match. We evaluate speculative actions across gaming, e-commerce, and web search environments, and additionally study a lossy extension in an operating systems setting. Across domains, we achieve up to 55% next-action prediction accuracy, translating into substantial latency reductions. Finally, we present a cost–latency analysis that formalizes the tradeoff between speculative breadth and time savings. This analysis enables principled tuning and selective branch launching, to ensure multi-branch speculation delivers practical speedups without prohibitive cost growth.

Published as a conference paper at ICLR 2026
SPECULATIVE ACTIONS: A LOSSLESS FRAMEWORK FOR FASTER AGENTIC SYSTEMS
Naimeng Ye; Arnav Ahuja; Georgios GeorgiosLiargkovars Yunan Lu; Kostis Kaffes, Tianyi Peng Columbia University New York, New York, USA [ny2336, aa5790, g12902, y14021, kk3664, tp2845)@columbia.co edu
ABSTRACT
AI agents are increasingly deployed in complex, interactive environments, yet their runtime remains major bottleneck for training, evaluation, and real-world use. Typical agent behavior unfolds sequentially, where each action requires an API call that can incur substantial latency. For example, game of chess between two state-of-the- agents can take hours. We introduce speculative actions, a lossless acceleration framework for general agentic systems. Inspired by specu- lative execution in microprocessors and speculative decoding in LLM inference, our method uses faster models to predict likely future actions and executes them in parallel, committing only when predictions match. We evaluate speculative actions across gaming, e-commerce, and web search environments, and addition- ally study lossy extension in operating systems setting. Across domains, we achieve up to 55% next-action prediction accuracy, translating into substantial la- tency reductions. Finally, present cost-latency analysis that formalizes the tradeoff between speculative breadth and time savings. This analysis enables prin- cipled tuning and selective branch launching, to ensure multi-branch speculation delivers practical speedups without prohibitive cost growth.
INTRODUCTION
Large language model (LLM)-driven agents are shifting from single-shot predictions to processes that run inside rich environments: browsers, operating systems, game engines, e-commerce stacks, and human workflows. These environments are not incidental; they determine what the agent can observe and do, gate progress through interfaces and rate limits, and dominate end-to-end latency. In practice, agent behavior unfolds as a sequence of environment steps (tool calls, Model Context Protocol (MCP) server requests, human-in-the-logy queries, and further LLM invocations), each with non-trivial round-trip time and cost. As capabilities improve, a new bottleneck emerges; time- to-action in the environment. Even when accuracy is high, an agent that pauses too long between steps is impractical for interactive use or high-throughput automation.
OS Tasks
Deep Research
Data Pipeline (Jin et al., 2025)
Kaggle Chess Game (Kaggle, 2025)
(Abhyankar et al., 2025)
(OpenAI, 2025)
10-20 min
5-30 min
30-45 min
hour
Table 1: Estimated time state-of-the-art AI agents spend on various tasks/environments.
As shown in Table 1, Al agents may require tens of minutes to hours to complete single run across different environments, a cost that grows significantly when hundreds or thousands iterations are needed for reinforcement learning prompt optimization (Agrawal et al., 2025).
This inefficiency arises from the inherently sequential nature of API calls. Thus, we ask a simple question in this paper:
Must an agent interact with its environment in a strictly sequential manner?
"Equal contribution

---

Published as a conference paper at ICLR 2026
Son-Speculative
Speculative
4, = [e2e4]
4-11
[S5c7]
Actor
Actor
4, [e2e4]
Actor
Validate Prediction
a/ [d2c4]
+ d
Actor
[c5e7]
741
Speculator
[22e4] Actor
t
Fast speculation
Time Saved
Figure 1: Illustration of our framework chess-playing environment. While the Actor issues an LLM call to decide the next move, the Speculator uses faster model to guess it. These guesses enable parallel API calls for the next steps, and once a guess is verified, the system gains time through parallelization. The process runs in the backend, ensuring a lossless speedup for the user.
Our answer is no. Inspired by speculative execution in microprocessors and speculative decoding for LLM inference, we propose speculative actions: general framework that allows agents to predict and tentatively pursue the most likely next actions using faster models, while slower ground- truth executors (powerful I.LMs, external tools, or humans) catch up. In effect, the agent stages environment interactions (prefetching data, launching safe parallel calls, and preparing reversible side effects) so that validation, not waiting, the critical path. When those slower evaluators confirm the guesses, progress has already been made; when they disagree, execute usual. The result is an as- as-if-sequential. lossless interface with parallel, opportunistic internals.
Concretely, in such agents, speculative actions introduce two roles in the environment loop:
authoritative but slow executors (e.g., SOTA LLMs, external APIs, environment's 's own responses, or humans) whose outputs materialize the ground truth for correctness and side effects.
Actor(s):
Speculator(s): inexpensive, low-latency models that predict the next environment step, i.c., the action, its arguments, and the expected observation or state delta. Examples include smaller LLMs, same LLM with reduced prompts and reasoning steps, and domain heuristics.
key design goal is losslessness relative to the environment's baseline semanties: speculative ac- tions should not degrade final outcomes compared to a strictly sequential agent. We achieve this with (a) semantic guards (actors confirm equivalence of state transitions before commit), (b) safety envelopes (only idempotent, reversible, sandboxed speculative side effects), and (c) repair paths (rollback or compensating actions when a guess is rejected). many environments (e.g., web search, pre-checkout shopping carts, and OS-level operations in sandbox) these patterns natu- ral and inexpensive to implement.
Can guess the next API calls of agents? We show that, in practice API intents often be guessed with reasonable accuracy. In particular, we demonstrate speculative actions across four environments, each highlighting different aspects of agent latency:
Turn-based gameplay (e.g.. chess): the Speculator predicts the opponent's 's move while waiting for its turn. See Fig.
E-commerce: while conversing with a shopper, the Speculator proactively infers the shopper's intent (e.g., returning an item). and triggers tool calls in advance (e.g., checking return eligibility).
Multi-hop web search: while awaiting results from slow external calls (e.g., Wikipedia), the Speculator can guess answers from its knowledge base, and execute subsequent search queries.
Operating systems (lossy extension): speculative, reversible actions react immediately to work- load and environment changes, boosting end-to-end performance while actors confirm.
2

---

Published as a conference paper at ICLR 2026
Across these settings, we observe substantially reduced latency, with up to 55% accuracy in pre- dicting the next API calls and 20% end-to-end speedup. These results are achieved with a simple single-step speculation, and can be improved by advanced techniques such adaptive speculation.
Finally, we give a cost-latency analysis that formally characterizes the tradcoff between speculating additional API calls and the resulting time savings. We provide theoretical baseline for choosing the speculative breadth, and show that the cost incurred by confidence-basee selection grows sub- stantially slower than naively scaling the number of speculative branches. Furthermore, in our OS- tuning environment where losslessness is not required, cost and latency can actually both decrease. Our code is publicly available at https: h/t::/giittttt thub. com htt///mmmmnnyeepeeelattiicee
1.1 RELATED WORK
Speculative decoding and reasoning Our work is inspired by the use of speculative decoding in LLM inference. This technique accelerates autoregressive inference by using a small model to propose tokens which larger target model verifies in batches, committing correct tokens and regenerating failures (Leviathan et al., 2023; Zhang et al., 2024; Chen et al., 2023). At the reasoning level, speculation has also been used to accelerate thain-of-thoughh (Wang et al., 2025b;a; Fu al., 2025). Our framework adopts the same speculate-verify pattern at the level of API calls.
Speculative planning for LLM agents More directly related are recent works on speculative planning for LLL--based agents (Hua al., 2024; Guan et al., 2025). Hua al. (2024) introduce interactive speculative planning, where a fast approximator proposes multi-step lookahead plans that are verified by stronger model, with user interruption integrated. Their approach focuses on depth- oriented speculation along single planning branch. Building on this, Guan et al. (2025) propose an online reinforcement learning method dynamically determine the number of future steps to speculate, optimizing cost-latency tradeoff while maintaining lossless execution.
Our work differs along two dimensions. First, we generalize speculation beyond planning to the entire agentic environment, including LLM calls, internal and external tool APIs, MCP-server inter- actions, and even human responses. This yields a unified framework for agentic speculation, partic- ularly consistent with the emerging "environment" and MCP perspectives on agentic systems. Sec- ond, instead of depth-focused multi-step lookahead, we study a breadth-focused k-branch single-step strategy, where multiple actions are speculated in parallel at each step. We provide cost-latency analysis for this scheme and derive closed-form expressions for expected time and token savings (Theorem 4). Section 5 compares breadth- and depth-focused strategies under unified analyti- cal framework. While Guan et al. (2025) optimize depth dynamically, we characterize the optimal number of speculative branches per step as function of predicted accuracy (Section 5.2).
Speculation in systems and architecture Speculation is prominently used in computer architec- ture increase parallelism by executing instructions before their outcomes were resolved (Toma- sulo, 1967) and rolling back when predictions were wrong (Lam & Wilson, 1992). In light of se- curity vulnerabilities that exploit microarchitectural speculative execution, (Mambretti et al., 2019) developed Speculator to analyze CPU speculation behavior.
Similar ideas arise in systems software as thread-level speculation, which parallelizes sequential code under assumed independence and rolls back upon detecting data dependencies or conflicts (Es- tebanez et al., 2016). Recently, (Liargkovas et al., 2023) explored the use of tracing and containment to speculatively but safely run shell scripts out of order. Beyond traditional systems context, specula- tive techniques have also been used to parallelize otherwise sequential security checks (Nightingale et al., 2008) configuration changes in isolation (Su et al., 2007), and accelerate policy simulation in supply chain optimization (Farias et al., 2024).
2 FRAMEWORK
An agentic system is modeled Markov Decision Process (MDP) (s,, a,), where s, denotes the state and a, the agent's action at step r. This model admits considerable flexibility: an action may represent chatbot response, a tool call, or button clicked by a computer-use agent, among others.
3

---

Published as a conference paper at ICLR 2026
From a systems perspective, model each action in agentic system API call, which may block execution until a response is returned. This abstraction offers two key advantages: (1) precisely defines what constitutes action, and (2) it provides unified framework for optimizing system latency, as we will see shortly. Notably, this perspective aligns with the recent development of MCP servers for agentic systems (Anthropie, 2024).
Formally, at each step 1, the policy л maps the current state 5, to an API call:
(h,44) x(s)),
where h, specifies the target API to invoke and qi its associated parameters. We write
en h,(g,) a, await(ā,)
to denote an asynchronous API invocation that returns a future (a pending action), and the await for when the response actually arrives. We use the bar notation (e.g.. @) for futures and cache (h, 4) + à that maps an API call specifier to its pending response. The left squiggly arrow indicates asynchronous call with non-negligible delay.
The system subsequently transitions to the next state via a transition function f: S411 - f(s,, a.). As concrete example, consider chess: the policy determines how to construct the prompt based the current board state, a; corresponds to the move proposed by the LLM's response, and f updates the board configuration accordingly. Note that the L.LM call is the API, its response is the move a,
This formulation subsumes a broad range of realizations:
LLM calls: each invocation of an LLM within the agent can be treated as an action.
Tool / MCP server calls: each actual call for internal/external tools is treated as an action: e.g.,
terminal access, web search, deep research APIs, weather APIs, or browser-use MCPs.
Human-as-an-API calls: furthermore, human responses themselves can abstracted as API calls, often incurring even longer latencies than automated tools.
Given this abstraction, the fundamental bottleneck in executing agentic systems becomes apparent: each API call must complete before the next can be issued. To break this sequential dependency, we propose to speculate set of API responses (å,) using faster model while waiting for the true response a, This enables speculative API calls for step / + to be launched in parallel. At time if the API call (h,, q:) can be found in the cache (cache hit). the system can skip the actual invocation and only wait for the pending action corresponding to this call to return (if not already returned). Formally, the algorithm is specified in Algorithm 1.
The resulting speedup relies on two key assumptions:
Assumption (Speculation accuracy). The speculative model & guesses the current-step response accurately enough that the implied next call (h+1,9941) = r(( â.) matches the true next call with probability p
As shown later, this often holds in practice because API responses are typically predictable.
Assumption 2 (Concurrent, reversible pre-launch). Multiple API calls can be launched concur- rently, and pre-launched calls that do not correspond to the realized trajectory have no externally visible side effects (or can be rolled back).
In practice, this assumption is satisfied under modest traffic for many external APIs (e.g., web search, OpenAl LLM queries, email lookups). For self-hosted LLMs, concurrent calls also incur only minimal additional cost due continuous batching.
We can then establish the following result (with proof deferred to the Appendix A).
Proposition 1. Under Assumptions 1-2, suppose at each step the speculative branch implies the correct next call (ht-1 9r+1) with probability independently across [1,T- T-1,-117 1]. Let the latency of & be Exp(a) and the latency of the actual API call be Exp(ß) with ß < a. All latencies and guesses occur independently. Assume the transition if and API parameter construction a are negligible. Then the ratio between the expected runtime of Algorithm 1, denoted B[T's) and the expected runtime of sequential execution, B[ segb. is
E[T.1
a
(T - 1)p()
2(k)
p(K p()))
(-p(k))
T-
p(k)
a
E[T
T Ta+ B
1 p(k)
(1 p()))
1+ p(k)
a +
where p(k) (1 p)* denotes the probability of at least one of the speculations hit.
4

---

Published as a conference paper at ICLR 2026
Algorithm Speculative actions with k-way parallel next calls
Require: Initial state So. horizon 7, transition f. policy x, predictor g. cache C. We use ā to denote pending action.
1: for /= to 7- do
2: Policy: (h, qi) - x(s,)
3: if (h, q:) E then
Cache hit
4:
a; - C( 4:)
5:
a: await(ā,)
Await pending action if not returned already
6:
S,11 - f(s,
7:
continue
8: end if
9: Actor: Issue real request (returns future): ā, h((q,)
Speculator: (a liml await(g(s; (h,, 4:))
Actor and speculator run in parallel One-step speculative rollout per guess
11:
for i= to k do
12:
(s..a
13:
21 (-1 - -(1
14:
Pre-launch: dz0l om R (9
20)
Return pending action, hence non-blocking
CIC 141 9 am
Cache speculative pending actions
16:
end for
Wait for resolved a, from Actor: a, - await(ā,)
18:
5;+1 < a))
19:
end for
Proposition suggests the end-to-end latency reduction has an upper bound of 50%, occurring when I and a = oo. This can be further improved by the multi-step extension below.
Extension Algorithm I is only simple demonstration of the idea. For example, one can naturally extend Algorithm to multi-step speculation, where the Speculator predicts not only the next, but steps ahead. This yields tree structure with deeper rollouts. This can be further combined with adaptive speculation: instead of generating & guesses for a, uniformly, the Speculator also estimates confidence for each guess (e.g., via prompting L.MMs or incertainty-quanfffccaais methods), this explored in Section5. The most promising branches manner. Together, these ideas highlight the richness of speculative actions. Despite Algorithm I's simplicity, the results from the four cases in the following sections already highly promising.
then be expanded in beam-scarch like
Side effects and safety Speculation executes a hypothesized next action a, that may be wrong, so safety requires the ability to simulate first and then commit roll back. In domains like chess, rollback is trivial; in others, overwrite is easy (e.g.. OS tuning). But many systems involve irre- versible externall visible effects (e.g.. deleting records, placing orders), where naive speculation is harmful. Thus, speculation must be limited to cases where mispredictions are reversible, via forking, snapshot restoration, roll-forward repair (e.g., refund/replace).
3 ENVIRONMENTS
We instantiate speculative actions in three environments-chess, e-commerce dialogue, and multi-hop web search-chosen to stress distinct latency bottlenecks (reasoning, tool/APl round trips, and information retrieval). We pair fast Speculator with slow Actor and implement Algorithm 1.
3.1 CuESS ENVIRONMENT
We demonstrate the effectiveness of our framework in the context of multi-agent gameplay, focusing on chess as a canonical turn-based example. In standard play, analysis is strictly sequential: each player begins analysis only after the opponent has completed their turn. This serialization introduces substantial idle time. Particularly when both players rely on computationally intensive reasoning models, a single game stretch to hours of wall-clock time. Our framework relaxes this constraint

---

Published as a conference paper at ICLR 2026
through speculative parallel analysis, allowing players anticipate and prepare for likely opponent moves in advance. We show that this results in significant reductions in overall game duration.
3.1.1 IMPLEMENTNTION
We implement our framework top of TextArena (Guertler et al., 2025), which provides stan- dardized gameplay interface for LLM-driven agents.
At turn the game state s, corresponds to the current board position. The in-turn player issues an API call h, with parameter q, constructed from s, together with reasoning- eliciting prompt. At this point, player is to move, and player Q awaits. Proceeds as follows:
Speculative pipeline
Current in-turn player P: the player receives 8,, makes an API call h, to the agent with parameter q: (s,, prompt). This API call returns the next move a, h(q)), typically with high latency due to deep and extensive reasoning.
Other out-of-turn player Q:
Prediction phase The Speculator also receives the board state s, and issues an API call h, using prompt optimized for speed rather than depth. It returns the top-k move predictions () (2) ..... a ordered by confidence.
2. Parallel computation For each predicted move a,", the out-of-turn player Q immediately launches process analyzing next move ( ( prompt) for i E (1,...,k) k), where / = f(s, a(")) denotes the next state resulting from applying the predicted action a,) to s,-
3. Validation When the current in-turn player P finishes reasoning and returns its move de immediately check whether it matches any of the predicted moves āi", .a." af").....!!!!
4. Commit or restart If match exists, we commit to the corresponding speculative branch, advancing directly to Si+1 = f(s. u.). The game thus skips ahead, terminating other threads. If no match exists, we discard speculative branches and continue with Q's regular move computation di+1 (f a,), prompt).
This pipeline is lossless: the final trajectory remains identical to non-speculative play, but time is saved through parallelized reasoning.
Agent Configuration We find that using the same model for both Speculator and Actor, but with different prompts, maximizes prediction accuracy while keeping speculation fast. Accordingly, in our experiments, the Actor instantiated with GPT-5 with high reasoning effort; and the Speculator is instantiated with GPT-5 configured with low reasoning effort and specialized system prompt designed for rapid move prediction rather than exhaustive analysis.
3.1.2 RESULTS
We evaluate framework in terms of both time saved and prediction accuracy. We track two metries: (i) prediction accuracy: the frac- tion of rounds in which any speculative pre- diction matches the actual move; and (ii) time
Speculative Accuracy (%)
Time Saved (%)
41.3%
Percentage
saved: (T veg T,)/T seg. where T, and Tseg
denote speculative and sequential execution times, respectively.
15.0%
More predictions improve time savings and accuracy. Figure reports results over 30 steps. Our framework consistently reduces execution time, with larger savings the num- ber of speculative predictions increases. Across 5 runs, using 3 predictions yields average time saving of 19.5% with an average predic- tion accuracy of 54.7%.
11.6%
15
prediction
2 predictions
3 predictions
Figure 2: Percentage of time saved and percentage of correct predictions across runs 30 steps.

---

Published as a conference paper at ICLR 2026
Randomness of agent call in gameplay. The variance in Figure 2 reflects realistic latency fluctu- ations from live API calls. Even with correct predictions, speedups vary: if the resulting position is trivial, little acceleration is realized; large gains occur only when predictions lead to positions requiring deep analysis. In addition, API latency itself is inherently stochastic. Backend load fluc- tuations (e.g., concurrent traffic to the model provider) can cause the same API call with different latency across runs. Consequently, measured latency reductions exhibit natural variability and are perfectly reproducible.
3.2
E-COMMERCE ENVIRONMENT
Beyond competitive gameplay, customer-agent interactions in e-commerce provide real-world set- ting where latency significantly impacts user experience. In a typical workflow, the customer sub- mits query through chat interface and waits while the agent sequentially invokes multiple API calls-for example, processing return may involve retrieving order information, validating eligi- bility for each item, and initiating the return. These chained calls can introduce substantial delay. By contrast, if some API calls are correctly speculated and executed in advance, the agent can return results immediately once the query arrives, making the interaction feel seamless. We evaluate this setting using the retail environment from r-bench (Yao et al., 2024).
3.2.1 EXPERIMENTAL SETUP
Speculative pipeline In this scenario, the current state is defined as the conversation history up turn r, and It, are the API calls required to answer the user's query (eg. get_user_dee dettail, prt_ooddr_detaill, Our Speculator will predict
Gemin 2.5 Flash GPT-5 family
Mult Agent
34 34.9%
34.2%
Afte treenettinn Accurssy
22.25
22,845
1. The user's query à;
2. The target API calls and their correspond- ing parameters (hth (++1 for i E [l.....k] k). conditioned on the current state s; and the predicted user's query from step 1. Since the number of API calls for each turn not fixed, the Speculator must also predict k.
Inw
medium
high
Reasoning Capability
Figure 3: APIs prediction accuracy across various Speculator models.
Agent configuration We evaluate multiple Speculator models, including OpenAl GPT variants (gpt-5-nano, gpt-5-mini, gpt-5) and Google Gemini (gemini-2.5-flash) under different reasoning budgets (1024/2048/4096 tokens). Motivated by prior work where heterogeneous LLM ensembles outperform single models (Jiang et al., 2023; Chen et al., 2025), we consider two configurations: (i) single-model Speculator, and (ii) multi-model Speculator, where comparable models run in parallel (c.g., gpt-5-nano with low-budget Gemini, gpt-5-mini with mediuum-budee Gemini). Their outputs aggregated into shared pool of candidate speculative actions.
At rumtime, once the user simulator reveals the ground -ruth utterance, the Actor validates the spec- ulative API calls: correct predictions committed immediately (eliminating latency), while incor- rect ones are discarded without affecting correctness.
Evaluation We evaluate performance using APIs prediction accuracy, defined as the fraction of speculative API calls that match the ground-truth APIs required to resolve the user's query. This metric directly reflects the proportion of turns in which the user receives an immediate response, without waiting for API execution: higher prediction accuracy translates into greater time savings.
3.2.2 RESUITS
Figure 3 shows that between 22% and 38% of API calls are correctly predicted by the Speculator. Accuracy improves with stronger models and the multi-agent configuration consistently outperforms single-model speculation. Importantly, luwgbt models speculate in only 2-3 seconds (per the LLM API providers leaderboard"), well below the average user typing time of about 30 seconds (assuming 40 words per minute). This means that in roughly one third of turns, the agent can respond faster than sequential execution, without waiting for API execution.
"htrps:/aartifficillaaala httpa///lammmmaas.aaaaaaaaaarrro

---

Published as a conference paper at ICLR 2026
3.3 HOTPOTQA ENVIRONMENT
We further evaluate our framework on HotpotQA, setting where the main performance bottleneck arises from information retrieval latency. In this ex- ample, the agent must answer multi-hop questions through sequential Wikipedia API calls (Yang et al., 2018), mirroring real-world agentic workflows with high round-trip network latency. In this setting, the Speculator predicts likely Wikipedia content while the actual API call executes. Parallelism allows the agent to continue reasoning on provisional informa- tion rather than blocking on API latency. See Ap- pendix B.2 for details about our experimental setup.
Accurac
46.25%
38.33%
Accuracy
31.67%
10.58%
gpt-5-nano gpt-4.1-nano gemini-2.5
Figure 4: Accuracy with gemini-2.55 2.5-faahh as the Actor. Speculating multiple actions (k 3) yields higher accuracy than predicting single action.
We evaluate the accuracy of the predicted API calls. As shown in Figure 4, the Speculator success- fully predicts ground truth API call up 46% of the time with top-3 prediction. This accuracy improves significantly from top-1 top-3 predictions, yield- ing substantial accuracy gains with modest speculation width increase. Our speculation provides value by precomputing reasoning paths during otherwise idle API waiting time.
4 BEYOND LOSSLESS SPECULATION: OS HYPERPARAMETER TUNING ENVIRONMENT
Thus far, our experiments have focused on lossless speculation, where speculative actions are vali- dated sequentially before commitment. We now turn to lossy setting that relaxes this constraint. In latency-sensttive environments like an operating system, waiting for powerful but slow Actor (10- 15s deliberation) can leave the system in a degraded state, Instead, we use fast Speculator to apply immediate provisional adjustments while the Actor deliberates. This is made safe by last-write- wins mechanism the Actor's final decision simply overwrites any speculative action, removing the need for complex rollbacks. This method accelerates convergence and improves reaction time, which we evaluate on the sysbench cpu benchmark, a CPU-bound workload (Kopytov, 2020).
4.1 EXPERIMENTAL SETUP
We tume Linux's 's Completely Fair Scheduler (CFS) parameter min- gww.glarrntttyya which controls task's 's minimum timeslice. This knob strongly affects scheduling performance: smaller timeslices reduce latency but can degrade throughput, yielding classic trade-off. Building (Liargkovas et al., 2025), we augment the prior L.LM-based tuning setup with speculative control loop.
The Speculator proposes a parameter update each second using the latest performance metric. The Actor, in contrast, responds every 10-15 seconds after analyzing a compressed chronology of the Speculator's recent (measurement, action) pairs. Upon arrival, the Actor's decision is applied im- mediately and its state resets the Speculator's context, preventing drift from the validated narrative.
Evaluation We evaluate three systems: (1) Actor-only: slow but deliberative (10-15s interval); (2) Speculator-only: fast (I interval) but non-extensive; (3) Speculator-Actor: combined system using speculative updates between Actor decisions.
4.2 RESULTS
Speculator mitigates poor-reaction slowdowns. As shown in Figure 5 (right), the Speculator significantly improves reaction time. During recovery, the full Speculator-Actor system maintains an average p95 latency of 37.93 ms, compared to 54.00 ms for Actor-only, which remains longer in degraded states (initially 102.97 ms). Fast speculative updates provide immediate mitigation while the Actor deliberates (details $B.3.3).
Speculator accelerates convergence to optimum. Figure 5 (left) shows that the joint system reaches the optimal setting (0.2 ms hii.granullrity) in 10-15s, whereas Actor-only requires -200s and remains trapped in highly suboptimal regions (e.g., latency > 120ms) for extended peri- ods. Rapid speculative exploration helps the Actor avoid pathological configurations.
8

---

Published as a conference paper at ICLR 2026
granularrtty (ms)
Actor-only
Optimal Region Default
Speculator-only
Configuration
Latency p95 (ms)
Actor Speculator
Untuned Actor-only
102.97 54.00
0.1
Actor Spec. 37.93
0
50
100
150
200
Time (s)
Figure 5: (Left) Comparison of Speculator-Actor, Speculator-only. and Actor-only convergence. The Speculator shortens time spent exploring poor settings. The Speculator-only agent stabilizes quickly but at worse final value. (Right) Average p95 lateney over 20-second tuning experiment showing that rapid reaction offers immediate performance benefits (see $B.3.3). Lower is better.
Speculator-only reacts quickly but is suboptimal. While Speculator-only stabilizes rapidly, converges to a worse configuration (0.55 ms; 36.24 ms latency) than the joint system (0.2 ms; 30.26 ms). Without the Actor's deeper reasoning, cannot escape local minima.
Cost and latency both decrease. Despite additional speculative calls, total cost is lower due faster convergence. As shown Table 3, Actor-only converges at ~200 with total cost of 2. 2.18 cents, whereas Speculator-Actor converges in ~13 with only cents.
Overall, the joint system combines fast adaptation with strategic guidance, achieving both respon- siveness and optimal steady-state performance.
5 COST-LATENCY TRADEOFF
Performing more speculative API calls improves accuracy but also raises costs when pricing is based on the number of calls or tokens. this section, assume fixed token per unit time and fixed per token cost, and analyze the cost-latency tradeoff. Full details be found in Appendix C.
5.1 BREADDH--OOUUED SPECULATION (ALGORITHM 1)
In addition to Proposition 1, we obtain closed form expression for relative cost increase ratio
B[
Mseql
p(k)
lim -100
S =k-(k=
kk a B 1 p(k)
B[Msaq]
See Theorem 4 in Appendix C for the formal theorem. Comparing Proposition 1 with the above expression, we see that both ratios are governed by p(k). Thus, given an estimation of p(k), a user can directly tune & offline, trading off against latency. Our experiment (Figure 6) shows this non-linear dependence on k, and additional empirical results can be found in Appendix C.2.
5.2 DYNAMIC SELECTIVE SPECULATION.
So far we assume a fixed branch accuracy p. In practice, we sometimes are able to obtain per- speculation confidence estimates (e.g., from intrinsic model logits, from separately-train -raineed aux- iliary predictor), allowing confidence-aware selective speculation. At each speculation window, the accuracies of the & speculative branches are random and drawn from known distribution (which may vary over time). Before acting, the realized accuracy vector = (p'....,p" p²) is observed, and choose how many of the top branches launch.
We model the cost-latency tradeoff via the weighted objective
max
latency - cost
where r and encode the relative importance of latency and cost. For simplicity, let a and b denote fixed latency of the actor and speculator, and define the latency gain & r(a - b)

---

Published as a conference paper at ICLR 2026
If the top branches are launched, the probability of a cached step is q(m;; p) = - p pl), where p 2 2 plk) are the sorted confidences.
Porcentagg of Extra Tokens Used (Ng
opeculationn
Theorem 3 (Confidence-awan selective specula- tion). There exist scalars 4 such that at each spec- ulation window 1, the optimal breadth satisfies
b-99 Stept mem
m (p) E arg max (q(m; p) A cm).
me(O....k)
The continuation values are given by the backward recursion
threchold
Ar =0
ABT-1= maxig(m; P) cm
speculatiio
Percentage Time Spent (%)
In the stationary case (time-homogeneous aCCu- racy distribution), the continuation values A col- lapse to single constant A². Thus branches are added greedily in descending confidence order while A öq(m; p) 2 c, where öq(m: p) is the marginal gain from adding more branch.
Figure 6: Cost-latency tradeoff across different speculation widths, forming Pareto curve.
Interpretation and implementation The key implication is structural: dynamic selection col- lapses to oie-dimensional trade-off. Additional branches are launched only when their incremental hit probability, scaled by a single continuation value (A, or A*), exceeds the marginal cost c. Under stationarity, this reduces estimating A offline; at runtime, the system simply sorts confidences and adds branches greedily, requiring O(k) computation per step.
Empirical results We implement simple constant- thressholthhhhdd approximation of the stationary rule in the chess environment. At each step, after generating speculative branches, we use a predictor to estimate the correctness probability of each branch and continue only with those whose predicted accuracy exceeds 50%. This implements simplified threshold rule consistent with the structure suggested by Theorem Our method achieves the lowest additional token cost while providing greater latency reduction than naively launching or 2 speculations per step.
5.3
DEPTH-FOCUSED SPECULATION.
The previous two strategies are breadth-focused: each speculation is immediately followed by a real API call (speculative depth 1). Additionally, we analyze the opposite extreme: depth-focused pol- icy, in which multi-step speculations are continuously spawned. Somewhat counterintuitively, this strategy does not lead to exponential branch growth. Speculative calls are only extended when either speculative or real call returns, and inconsistent subtrees are immediately pruned. Consequently, the system can run at most a/b speculative steps ahead (governed by the relative speeds of real vs. speculative calls), ensuring that the number of active branches remains bounded and does not scale with the horizon T. Under this policy, we can show that (formal theorem in Appendix 6)
E|Tsop T spee
T T r 11-2) ")
BLMspec Mssgg
T
a
T p)
(1
+
B(T
B[Maeql
2h
2
Compared to breadth speculation, depth speculation improves the latency coefficient from 1+p p, increasing the theoretical speedup ceiling from to 1. The cost term scales with (1 - p) 20 } which captures how many speculative steps can accumulate before the real response arrives.
6 CONCLUSION
In this paper we propose Speculative Actions, lossless framework for accelerating general agen- tic environments by breaking the strict sequentiality of their interaction loops. Our approach treats every step, whether an LLM call, tool invocation, MCP request, or human response, an API call subject to prediction and parallelization. By pairing a fast Speculator with a slow but authorita- tive Actor, the framework enables agents to anticipate and prepare likely next actions in parallel, transforming otherwise idle waiting time into productive computation. We instantiate the frame- work across four representative environments and observe consistent substantial latency reduction. Finally, we provide cost-latency analysis that addresses the tradeoff between the additional cost and the latency gains from launching additional speculative actions.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGMENTS
This work supported by Columbia-Dream Sports Al Innovation Center
REFERENCES
Reyna Abhyankar, Qi Qi, and Yiying Zhang. Osworld-human: Benchmarking the efficiency of computer-use agents. arXiv preprint arXiv:2506.16042 2025.
Lakshya Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong Arnav Singhvi, Herumb Shandilya, Michael J Ryan, Meng Jiang, et al. Gepa: Reflective prompt evolution can outperform reinforcement learning. arXiv preprint urXiv:2507.194555 2025.
Anthropic. Introducing the model context protocol. https://ww, https://ww..athhopicc..o model-context-ppee protooll, November 2024. Accessed: 2025-09-24.
Charlie Chen, Sebastian Borgeaud, Geoffrey Irving, Jean-Baptiste Lespiau, Laurent Sifre, and John Jumper. Accelerating large language model decoding with speculative sampling, 2023. URL
https://arxiv..org/atte wt3.o/////.//././//ooooo 01318.
Zhijun Chen, Jingzheng Li, Pengpeng Chen, Zhuoran Li, Kai Sun, Yuankai Luo, Qianren Mao, Ming Li, Likang Xiao, Dingqi Yang. Yikun Ban, Hailong Sun, and Philip S. Yu. Harnessing multiple large language models: survey Ilm ensemble, 2025. URL https://arxiv.org/ abs/2502.1800 18036.
Dmitry Duplyakin, Robert Ricci, Aleksander Maricq, Gary Wong, Jonathon Duerig, Eric Eide, Leigh Stoller, Mike Hibler, David Johnson, Kirk Webb, Aditya Akella, Kuangching Wang, Glenn Ricart, Larry Landweber, Chip Elliott, Michael Zink, Emmanuel Cecchet, Snigdhaswin Kar, and Prabodh Mishra. The design and operation of CloudLab. In Proceedings of the USENIX An- nual Technical Conference (ATC), pp. 1-14, July 2019. URL paper/ / duplyakinllaaaoaaamaaaaa atc19.
flux. utah. edu/
Alvaro Estebanez, Diego R. Llanos, and Arturo Essrilo A survey on thread-level speculation techniques. ACM Comput. Surv., 49(2), June 2016. ISSN 0360-0300. doi: 10. 10.1145/ 2938369. URL https://doi. (erdiii.gg//i// 1tgg/99.114//29999
Vivek Farias, Joren Gijsbrechts, Aryan Khojandi, Tianyi Peng, and Andrew Zheng. Speeding up policy simulation in supply chain rl. arXiv preprint arXiv:2406.01939 2024.
Yichao Fu, Rui Ge, Zelei Shao, Zhijie Deng, and Hao Zhang. Scaling speculative decoding with lookahead reasoning. arXiv preprini arXiv:2506. 19830, 2025.
Yilin Guan, Wenyue Hua, Qingfeng Lan, Sun Fei, Dujian Ding, Devang Acharya, Chi Wang, and William Yang Wang. Dynamic speculative agent planning, 2025. URL https://arxiv, http://xxxvvogg/////// abs/2509.0110
Leon Guertler, Bobby Cheng. Simon Yu, Bo Liu, Leshem Choshen, and Cheston Tan. Textarena, 2025. URL httptttt/a/xxi....to wrt.v../rgaabs//544.4 11442.
Wenyue Hua, Mengting Wan, Shashank Vadrevu, Ryan Nadel, Yongfeng Zhang, and Chi Wang. Interactive speculative planning: Enhance agent efficiency through co-design of system and user interface, 2024. URL aattps://artii wrg. abs/2410. 00079.
Dongfu Jiang, Xiang Ren, and Bill Yuchen Lin. LLM-blender: Ensembling large language mod- els with pairwise ranking and generative fusion. In Anna Rogers, Jordan Boyd-Graber, and Naoaki Okazaki (eds.), Proceedings of the 61st Annual Meeting of the Asxociation for Com- putational Linguistics (Volume 1: Long Papers), pp. 14165-14178, Toronto, Canada, July 2023. Association for Computational Linguistics. doi: 1336633/1/0022.aalllooo 792. URL https://aclantholloe wwwp//22........... acl-long 792/.
Tengjun Jin, Yuxuan Zhu, and Daniel Kang. Elt-bench: An end-to-end benchmark for evaluating ai agents elt pipelines. arXiv preprint 2488088544. 2025.

---

Published as a conference paper at ICLR 2026
Kaggle. Game arena. https://ww..kgght www.://lw....oommmmmemmoeme arena, 2025. Accessed: 2025-09-21.
Alexey Kopytov. Sysbench: Scriptable benchmark tool. https://github..cmm/aa sysbench, 2020. Accessed: 2025-09-22.
Monica S Lam and Robert P Wilson. Limits of control flow on parallelism. ACM SIGARCH Com- puter Architecture News, 20(2):46-55) 1992.
Yaniv Leviathan, Matan Kalman, and Yossi Matias. Fast inference from transformers via speculative decoding. In International Conference Machine Learning, pp. 19274-19286, PMLR, 2023.
Georgios Liargkovas, Konstantinos Kallas, Michael Greenberg, and Nikos Vasilakis. Executing shell scripts in the wrong order, correctly. In Proceedings of the 19th Workshop on Hot Topics in Operating Systems, pp. 103-109, 2023.
Georgios Liargkovas, Vahab Jabrayilov. Hubertus Franke, and Kostis Kaffes, An expert in residence: Lim agents for always-on operating system tuning. In Proceedings of the NeurIPS 2025 Workshop on Machine Learning for Systems (MLForSys), San Diego, CA, USA, December 2025. NeurIPS. Accepted paper.
Andrea Mambretti, Matthias Neugschwandtner, Alessandro Sorniotti, Engin Kirda, William Robert- son, and Anil Kurmus. Speculator: a tool to analyze speculative execution attacks and mitigations. In Proceedings of the 35th Annual Computer Security Applications Conference, pp. 747-761, 2019.
Edmund B Nightingale, Daniel Peek, Peter M Chen, and Jason Flinn. Parallelizing security checks on commodity hardware. ACM SIGARCH Computer Architecture News, 36:1)33000--110000 318, 2008
OpenAl.
Introducing
deep research. 2025.
https://openai. com/ieeee//cc////////////// Accessed: 2025-09-24.
Ya- Yunn Su, Mona Attariyan, and Jason Flinn. Autohash: improving configuration management with operating system causality analysis. ACM SIGOPS Operating Systems Review, 41()):337- 250, 2007.
Robert M Tomasulo. An efficient algorithm for exploiting multiple arithmetic units. IBM Journal of research and Development, 11(1):25-33, 1967.
Jikai Wang, Juntao Li, Jianye Hou, Bowen Yan, Lijun Wu, and Min Zhang. Efficient reasoning for ilms through speculative chain-of-thought, 2025a. URL 19095.
Zhihai Wang, Jie Wang. Jilai Pan, Xilin Xia, Huiling Zhen, Mingxuan Yuan, Jianye Hao, and Feng Wu. Accelerating large language model reasoning via speculative search, 2025b. URL https: //arxxv..orrg/ http//org//bboo ab////bs////0 02865.
Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William W. Cohen, Ruslan Salakhutdinov, and Christopher D. Manning. Hotpotqa: A dataset for diverse, explainable multi-hop question answering, 2018. URL https://arxii http://awvv.rgg//a////// /a//ab///88 1869. 09600.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting language models, 2023. URL htRpsts::/aaxiiv.oo abs/2210 03629.
Shunyu Yao, Noah Shinn, Pedram Razavi, and Karthik Narasimhan. r-bench: A Benchmark for Tool-Agent-Use Interaction in Real-World Domains, June 2024. URL http://arxiv.orrg abs/2406, 12045. arXiv:2406.12045.
Chen Zhang, Zhuorui Liu, and Dawei Song. Beyond the speculative game: A survey of speculative execution in large language models. arXiv preprint arXiv:2404.14897, 2024.
12

---

Published as a conference paper at ICLR 2026
A PROOF OF PROPOSITION 1
Proof. Baseline. In sequential execution, each of the 7' steps requires one call to the true model with mean latency 1/B. Therefore
B
Expected time saved per hit. Consider two consecutive steps (t, In the baseline, the total completion time B C. where B, C Exp(B) are the latencies step and step 1+1. With speculation, we launch A ~ Exp(a) during step 1. If the guess is correct, the (1+1) call C can be issued once either B finishes, so the block completes
5 C min(A, B).
Thus, when a guess correct, our expected time saved is
R-S (B A)+,
where (x), = max/xx, 0). By independence of A,
B[(B A)-]= ( ( (b- ae Be da Blar B)
Expected number of hits. We denote the expected number of hits by round n as S that is E[number of hits by round n] S,
We then have So 0, 1 = pk). round 1, either (i) we hit with probability p(k), in which case round 2 cannot be a hit (there is speculation window immediately after correct speculation), contributing 1+5 or (ii) we miss with probability 1-p(k), after which round 2 proceeds normally, contributing ---- We then have the following recursion
S, = p(k)1 S. + (1 p(K)) n-1
Solve this linear recurrence by splitting into homogeneous and particular parts.
(1) Homogeneous part
$ n- -p(k))
The characteristic equation is
2 (1 - p(k))r p(k) = (r- 1)(r +(k))
the roots are ri 1, = -p((k
Therefore,
5 = C1 + C2(-
(2) Particular solution The forcing term constant (+ (+p(k)), and is a root, so a constant trial collides with the homogeneous part. Try ((p(k)) an and substitute:
(1 p(k))a(n 1) p(k)a(n 2) + p(k) a(1 + p(k)) + p(k),
which gives a(1 p(k)) = pkk) and thus
(p()))
p(k)
+ p(k)
Combine:
p(k)
S, C1 C2(-p(k)))
1 p(k)
Use So and S = p(k):
p(k)
0= 0-C++ Cz.
p(k) = C2(-p(k) +
1 p(k)
13

---

Published as a conference paper at ICLR 2026
Solving yields C2 = (1 + p(k))² and Ci p(k)²
p(k)
(1 + p(k))²
Hence the closed form solution is
p(k)
p(k)²
n + +1+ p(k)) (1 - (-p(k))))
5, + p(k)
Total saving. There are T 1 potential speculation windows, hence
a -S--1 Bla B3
E[T,]
B
Final ratio. Dividing by E[T TIB gives
E[T.]
a
(T (1-1))p())
p(k)
(1+ (-()))-
p(k)
E
Ta+p + B 1 + p(k)
(1 + p(k))²
Taking 7 - oo, we get exactly that the ratio converges to
p(k)
T+p(A) a43
14

---

Published as a conference paper at ICLR 2026
B ADDITIONAL ENVIRONMENT DETAILS
B.I ECOMMERCE
r-bench: A benchmark designed for dynamic task-oriented dialogues between user (simulated by language models) and an API-augmented agent. The benchmark spans two domains - retail and airline, with structured databases, domain- -specicc tools. We focus the retail domain, where the agent assists users with operations such as canceling or modifying pending orders, initiating returns exchanges, providing product and order information. The benchmark defines 115 tasks with 15 APIs (7 write, 8 read-only).
B.2 HotPorQA
B.2.
EXPERIMENTAL SETUP
We build our framework upon ReAct (Yao al. (2023)), which interleaves chain-of-thought with tool use.
Speculative Pipeline this scenario, the state s, consists the entire history of reasoning traces and retrieved information (API responses). At each step, the Actor takes in the current state s selects an API call h, E (SearchO), Lookup(. Finish() and a corresponding parameter qı, e.g. Search(entity). The call h,(g)) returns response a, typically providing information about the queried entity. Our speculative framework operates as follows:
1. Speculator predicts the API call response a yielding predicted next states 310 r+t ie (I.
f( a
Based on the states, the Actor generates reasoning traces and subsequently determines the next API decision ( ( for (I.....k).
Evaluation We evaluate the effectiveness of the speculative pipeline by the accuracy of the predicted API call decisions (h+11. (.+)). Specifically, we compare the predicted call against the ground-truth call (14+1:9:+1) obtained under the true response a, We employ strict match criterion, counting prediction correct only when h111 h+11 and qi+1 q++1- This stringent criterion captures whether speculation enables meaningful progress, as even minor parameter differences (synonyms, word order) count mismatches.
Agent configuration We evaluate speculative accuracy across three Speculator models: GPT-5- nano, GPT-4.1-nan and Gemini-2.5- 2.5-faahh... For each model, measure the top-k prediction aceu- racy, with & E (1,3).
B.2.2 RESULTS
Figure 4 shows that our Speculator successfully predicts the ground truth API call up to 46% of the time with top-3 prediction, despite our strict matching criterion. This accuracy improves sig- nificantly from top-1 to top-3 predictions, demonstrating that modest increases in speculation width yield substantial accuracy gains. Our speculation provides value by precomputing reasoning paths during otherwise idle API waiting time.
We observe high variation API decision across different Speculators. These are largely driven by phrasing discrepancies some models phrase the calls concisely while some over- specify. Interestingly, stronger models often yield lower accuracy, as their more diverse and context- specific queries (e.g.. "List of Nobel laureates in physics 1970s" "1970s Nobel Prize Physics winners list") are penalized under strict matching. In contrast, weaker models tend to produce simpler, more predictable outputs.
Model Patterns
15

---

Published as a conference paper at ICLR 2026
B.3
OPERATinG SYSTEM TUNING
B.3.1 EXPERIMENTAL SETUP AND IMPLEMENTATION DETAILS
System and Workload Configuration All experiments were conducted on dedicated machine with 2x Intel Xeon Silver 41 14 10-core CPUs at 2.20 GHz, 192 GB DDR4 RAM, and a I TB NVMe SSD running Ubuntu 22.04 with Linux Kernel 5.15, hosted on Cloudlab (Duplyakin al., 2019).
We run sysbench cpu (Kopytov, 2020), CPU-bound benchmark that repeatedly calculates large prime number sequence. The benchmark reports several performance metrics every second. We run sysbench on 16 concurrent threads pinned on two CPU cores.
Tuner Implementation Details The system consists of two agents, fast Speculator and slow Actor, which collaborate to minimize the p95 latency of the workload. At each step, the tuner proposes new configuration, which is applied to the live system. Applying the proposed parameters is a near-instant operation.
CFS Parameter Details The Completely Fair Scheduler (CFS) is CPU scheduler for Linux that aims to give every task a fair share of CPU time. It exposes various hyperparameters that allow administrators to adjust its behavior. We tuned min waanngrannaaarrr ammulrrie ty nss which enforces minimum timeslice a task will receive. The prompt templates guided the agents to explore a range from 50,000 50,000,000 nanoseconds (0.05 ms 50 ms). The default value on Kernel 5.15 is 3 ms. Lower values for this parameter are expected to increase responsiveness at the cost of higher context- switching overhead, while higher values improve throughput but can worsen latency.
History Compression and Context Management To manage context window limits and costs, employ different context strategies for the combined system versus the baselines.
In the Actor-only and Speculator-only baselines, the agents receive the full, unsummarized history of all previous iterations. For the Actor-only baseline, the low frequency of interaction (once every 10-15s) means the context grows slowly, rendering compression unnecessary within the benchmark duration.
In the Speculator+AActor combined system, history is managed via distinct prompt structures. When the slower Actor is invoked, its prompt context contains fully compressed summary of all actions taken during its deliberation window. Each action from the Speculator is listed as a con- cise (parameter, result) pair. In contrast, the faster Speculator receives a hybrid context: it sees the same compressed history from the last Actor cycle, supplemented by the full, verbose replies from its own most recent actions. This dual-context mechanism allows the Actor analyze long-tew term trends from compact summary, while the Speculator retains immediate, detailed context for its rapid, reactive decisions.
B.3.2 PROMPT ENGINEERING FOR MULTI-AGENT OPTIMIZATION
The following the prompt templates used to guide the LLM agents.
16

---

Published as a conference paper at ICLR 2026
Initial System Prompt for Actor and Speculator
You Linux kernel scheduler tuning expert with deep knowledge of the Completely Fair Scheduler (CFS).
MULTI-AGENT ROLE:
You are part of MULTI-AGENT System.
[For Actor] You the Actor. Your role is to provide thoughtful. well-analyzed parameter recom- mendations. You work alongside Speculator that explores the parameter space rapidly. You will receive accumulated results from multiple agent calls to perform deeper analysis and identify trends.
[For Speculator] You are the Speculator. Your role is to provide immediate, intuitive parameter recommendations for each window. You work alongside Actor that performs deeper analysis.
Your goal to MINIMIZE p95 latency for a CPU-bound workload. The workload performance metrics might be NOISY, so look for consistent trends across configurations.
Tunable CFS parameter:
min- gramularity _n.s: ns: Minimum time slice before preemption. Lower values increase re- sponsiveness but also overhead. Higher values improve throughput but worsen latency.
Parameter Range:
min.gramularitt.... 50,000 to 50,000,000 nanoseconds
Performance data will be provided future calls. Respond ONLY in the format shown below:
Analysis: <Your one or two sentence decision reasoning>
Config: "min meiin.gramularrty..tm .ns <int>
Update for Speculator
[Context includes the compressed history for calls 1-10 and the raw Speculator responses for iterations 11-18)
CURRENT BEST: p95 latency=[value] call #[value]
Latest Result for call #19: Config: "min granularity ns" [value] p95 latency=[value]
Please provide your analysis and the next configuration for iteration #20.
Update for Actor
[Context includes the compressed history for calls 1-10]
CURRENT BEST: p95 latency=[value] call #[value]
RESULT for call #11 [SPECULATOR]: min min. coiingraallarity....o granularity.ss-vvluue) - p95 latency=(value)
RESULT for call #12 [SPECULATOR]: min min_ wog.graularttnnsssvlleeee [ns=uveluee] - p95 latency=[value]
RESULT call #19 [SPECULATOR]: min
- p95 latency=[value]
Please provide your analysis of the trend and the next configuration for call #20.
Sample Agent Response
Analysis: The performance peaked at 300,000 suggesting the optimal value is likely in that region. I will narrow the search around that peak. ("min traiingranularity.oo 250000
Config:
17

---

Published as a conference paper at ICLR 2026
B.3.3 SPECULATIVE REACTION TIME BENEFITS
To provide targeted example of how speculation mitigates transient performance loss, we con- ducted a controlled experiment. In this scenario, the system is deliberately perturbed at time to by setting the min aan-grrnuulaitty parameter to a highly suboptimal value (I0 ms). We then compare the system's s recovery under two configurations: the Actor-Speculator system and an Actor-Onl baseline, which replays only the actions proposed by the Actor from the full Actor-Speculator trace.
10
Speculator Actor Actor-only
min granularity (ms)
speculator response
actor response
0.1
5
10
15
20
Time (s)
Figure 7: A controlled experiment showing the system's 's step response after manual perturbation 0. The Actor-Speculator system corrects the poor setting within second, while the Actor- only system must wait over 10 seconds for its next decision cycle. The quantitative results of this experiment are summarized in Figure (Right) in the main text.
As shown in Figure 7, the Actor-Speculator system reacts almost instantly. The fast Speculator, seeing the immediate performance degradation, applies a corrective action that brings the system back an efficient state about one second. In contrast, the Actor-Only system forced endure the poor performance for over 10 seconds, as it must wait for the slower Actor to complete its deliberation cycle before it can act. The performance gap shown in the plot quantified in the main text (Figure 5, Right).
18

---

Published as a conference paper at ICLR 2026
C COST-LATENCY TRADEOFF
C.I BREADTH-FOCUSED SPECULATION DETAILS
Algorithm launches parallel speculative branches at any step e [l..... 7 1), which is then immediately followed with API call. We assume each branch independently produces the correct next call with probability p. Let
p(k) == Pr(at least one branch is correct) 1 -p)*
We assume the latency of speculative call is Exp(a), and the latency of a real API call is Exp(0) with B a. Let e denote the cost per unit time for both speculation and real API work. Let
BIT spec
B[Mspee]
denote the expected lateney and cost under Algorithm 1 (1 step breadth speculation), and similarly let (T Mseq) denote the sequential process with no speculation.
Theorem (Cost-Latenny, Tradeoff for Breadth Speculation). Under the setup above,
E
spee
(T 1)p(k)
p(k)
p(k)²
(1 p(k)) (-p(k))
E[T sey
Ta + B
1 p(k)
(1 p(k))
T-400
p(k)
a
1 + +pk(k + B
For cost, letting k denote the number of distinct actions produced across the k speculative branches,
B[M Msegl
k
k
(T - 1)p(k)
p(k)
(1 + p(k))² (-p(k))
p(k)
B[Mseq]
T
a B
1 p(k)
(1 + (k)p(
T-000
k
k az + B
a
p(k)
p(k)
Note that & is possibly different from k because the k independent speculations might have duplica- tions, in which case we kill the duplicated speculation processes.
Proof. The proof of the time savings ratio is given in Appendix A. For cost, we have
T B
seg x
Mapec T (k [k+ 1)- S
k
Bla B)
where the speculative expression is due each hit by time step will result in (i) the cached next step not having speculative window, hence does not launch any speculations (ii) over counting hit action's 's generation time with execution time.
Plug in expressions we obtained from Appendix A, we get the expression desired.
C.2 ADDITIONAL EMPIRCAL RESULTS
C.2.1 E-COMMERCE
Trade-off between Prediction Accuracy and Cost. The time cost in Figure 8a consists of latency (Time to First Token) and output response time. The dashed vertical line represents the average user typing time, estimated at 40 words per minute. At this threshold, the multi-agent setting achieves approximately 34% prediction accuracy, meaning that in over one-third of cases the agent can re- turn an immediate response without waiting for API execution. This demonstrates that speculation can transform user experience from perceptibly laggy to effectively real-time in tool-heavy environ- ments.
19

---

Published as a conference paper at ICLR 2026
Gempi-2.5Fath
family
famiy
Multi Agent
Mulli Aggett
User lime
Prediction
0.0e Price CostiTum (USD)
Time Cost/Turn
(8)
(b)
Figure 8: Prediction Accuracy against Speculator's Cost across different models. (a) Accu- racy-Speculator time cost trade-off across models. The dashed line shows average user typing time. (d) Accuracy-Speculatee price trade-off across models, reflecting the monetary cost of speculative execution.
C.2.2
OS
TUNING
10'
Cumulalivv Cost
10
10a
10
Cumulative
10*
10
10-4
10a
25
50
75
100
125
150
175
200
25
50
75
100
125
150
175
200
Time (6)
Time (6)
Speculetar-anly
Actor-only
Spec + Actor: Speculator
Spec + Actor: Actor
Spec Actor: Total
Figure 9: Cumulative token usage and cost over time. The left and right plots show the cumulative cost (USD) and total tokens used, respectively, for all three configurations. The vertical lines mark the observed convergence point for each system. The Actor-only model converges at 200s
Table 2:
Cumulative tokens and cost (in cents) selected time marks. While Speculation incurs higher instantaneous costs, its rapid convergence (bolded) prevents long-term resource waste com- pared to the slower Actor-only baseline.
Actor-only
Speculator-only
Actor Actor-Speculator (Total)
Elapsed Time
Tokens
Cost (cents)
Tokens
Cost (cents)
Tokens
Cost (cents)
Base Prompt
744
0.02
690
0.01
1434
0.03
13s
1,216
0.05
14,973
0.18
12,135
0.17
20s
2,211
0.09
27,654
0.34
20,504
0.31
30s
3,631
0.15
45,768
0.57
32,459
0.48
60s
8,581
0.35
205,794
2.24
84,568
1.18
120s
26,398
0.96
778,253
8.12
261,855
3.53
200s
63,376
2.18
2,099,894
21.5
607,877
7.83
Table
Impact of Context Strategy on Cost. While the Speculator operates at high frequency, the cost overhead is mitigated by the history compression mechanism described in $B...1. In the combined system, the expensive Actor model reads only compressed summary of the Speculator's many steps, rather than the raw verbose logs. This keeps the prompt size for the Actor relatively stable compared to linear growth of uncompressed history. As result, the cost difference between the Actor-only and Speculator+Actun systems is driven primarily by the number Speculator calls, rather than explosion in context size per call.
20

---

Published as a conference paper at ICLR 2026
As illustrated in Figure and detailed in Table 2, the high frequency of the Speculator leads to rapid growth token consumption and cost. In practice, however, this growth is bounded by the system's 's fast convergence. The combined Actor-Speculator system converges in approximately 13 seconds, while the Speculator-only system converges 20 seconds. The Actor-only system converges after 200 seconds. Once optimal state is reached, the tuning process concludes, rendering the poten- tial for long-term exponential cost negligible in this context. Several optimization strategies, like truncating the context to fixed window or disabling exploration after convergence, could further mitigate token growth but are left for future work.
C33 CONFIDENCT-AWAa SPECULATION
We formalize the branch selection problem introduced Section 5.2.
Model. Fix a horizon T and an integer k 1. At each epoch r, the system is in mode (0, 1):
0: a speculation window is available,
Z a cached correct action must executed (no speculation).
Let and b denote the actor and speculator latencies, respectively, and define the latency gain
= a b b>0 0,
which is collected only at epochs with 1.
Accuracy process. At epochs with & = 0, an accuracy vector P, = (P....., Pt) E [0, 1J' realized and observed. Assume P, F, independently across I, where the distribution F, may vary time.
Given a realization p. let p()) 2 ... 2 pd)) denote the sorted coordinates.
Action and hit probability. At 2, O, the agent chooses m, (O,..., branches at cost cm,, The probability of obtaining a cached action is
k), launching the top m,
g(:: p) 1 [ (1 D()) j=1
@0: p) 0.
Mode transition. If 1, then Z+1 0 deterministically. If z = 0 and action m is chosen,
1. w.p. q(m; P.).
Z+1
0. w.p. 1 q(:; P,).
Reward.
The per-epoch reward
C, R₂ =
2, 1, -mm, = O.
The objective is to maximize B Σ R.
We then present the proof to the first part (general non-stationary) of Theorem 3.
Proof. Let vith denote the optimal expected total reward from epochs f,..., with terminal conditions T+1 = v =
T' given mode 2, = 2,
By standard dynamic programming arguments, the Bellman equations are
((I) f+ (()) 1+1
y(O) Ep-r.
max -- cm + g(m; P) v()) mE(O....
rel + (1 - g(m; PJ) v00i
(2)
Define the continuation gap
p()
((0
1+1
21

---

Published as a conference paper at ICLR 2026
Substituting equation into equation yields
((t)
Bp-r: max(g(m: P) Ar - - H+1
Hence, conditional observing p at epoch I, the optimal decision maximizes
q(: p) A, cm.
establishing the stated policy. Finally, using
A, v(I) (-00 = = 1it v(0
7+1
and substituting the expression for pr0)) ++ gives the scalar recursion
( (- Fin Finl
maxiq(m; P) AH+1 cml}
with terminal condition Ay 0 (or equivalently, Ar-1 C).
We then formally describe the stationary average reward corollary. Corollary (Stationary infinite-horizon average-reward policy). Assume the nonstationary model becomes stationary:
P, F i.i.d. across f, the hit probability q(m; p) and cost are lime-invariant,
the objective is to maximize long-run average reward.
Let @(m) == Ep-mlm(m; P)] denote the expected hit probability when launching m branches.
Then the optimal average reward g* satisfies
q(m) e cm
8"
max me((O....k)
+ @(m)
Define
Then optimal stationary policy at a speculation window is
m" (p) arg max (q(m; p) A cm). me/O....k)
In parficular, the optimal policy mapping (the scalar A*) is time homogeneous.
Proof. Fix A 0. Conditional on observing at speculation window, the stationary one-step objective is
f(m; p) := 4(m; p) A
E (0, l.....k).
The first display in the corollary is exactly the definition of m (p) as any maximizer of f'm; p). To show the greedy marginal-thresholk form, note that for sorted confidences D!)) 2 p0)
((:: p) = M )
j=l
so the discrete marginal gain from adding the (m + 1)-th branch is
f(m 1:p) f(m:p) A s"((mm 1;p) q(n; p)) A 5g(m; p) c,
where
5q(m: p) q(m 1:p) g(m: p)
(1 p()))) ) (m+1))
22

---

Published as a conference paper at ICLR 2026
Moreover, dq(m;; p) is nonincreasing in (diminishing returns), since p! is nonincreasing and the prefactor [1 (1 pl) is nonincreasing in m. Hence the increments f(m + 1: - f(m; p) are
nonincreasing m as well.
Therefore there exists an index m mp) such that f(m 1;p) f(m; 2 0 for all m < m" m (p) and f(m 1;p) f(m; p) & for all m 2 m* (p). Equivalently.
A ōq(m: p) 2 c for m < m (p),
A -0 p) S for m 2 m mp),,
which is precisely the greedy stopping rule stated in the corollary.
C.4 DEPTH FOCUSED SEARCH
In the most general setting, a policy may choose both (i) how many parallel speculative branches to launch, and (ii) how "deep" to unroll each speculative branch before initiating a real API call. Analyzing the optimal policy in this full space highly non-trivial due the branching structure of the execution tree.
To build intuition, we analyze two extrema regimes: (1) a breadth-focused regime, where at each step we launch k parallel speculations and immediately follow each with an API call, and (2) depth-focused regime, where execution follows a single branch as far as speculation and real API calls allow. These two settings correspond to simplified extremes of the decision space, providing interpretable analytic characterizations the cost-latency tradeoff.
We analyzed the first in the previous section, and now analyze the opposite extreme: depth- focused strategy. Under this policy, whenever either a speculative or real API call returns, the system launches one real call and one speculation on top of that branch. If the real API result is incon- sistent with the corresponding speculative guess, all descendants of that speculation are discarded. Let be the per-step correctness probability of speculative guess.
Assume for simplicity that the real API call latency is deterministically a and a speculative call latency is b < a.
Theorem (Cost-Latency Tradeoff for Depth Speculation). Let p be the probability that a specu- lation is correct at each step. Then under the depth-focused policy described above,
B
50g
T
speel
T-
p 1 2
B[Tueg]
and the expected cost satisfies
B[M Maeql T (1
aL
T
a
(1 p)
B[Mscql
a
T
2h
Proof. We directly calculate the expected time cost of speculation execution as follows
T-1
T Typec = a +
p²(1 - -1- + (T - 1 ssaa
s
==0
Let
Binomial(T-11. 1,p),
so that
TT
P(S = 5) =
p'(1 p) T-1-x 0=..... T-1
Then
7-1
Σ
p'(1 - 7-1-p ssb + (T s)a
S=0
= E[Sb + (T - 1 5)a
b EIS] a S}.
23

---

Published as a conference paper at ICLR 2026
Since
B[S] (7 10 -)p,
we obtain
(T' - B(T - 11ppb-pa--
Therefore,
E(r-
T-1 T
T spec a
Σ 1=0
p'(1 p00--- + (T - s)a} aT + (T 1)p(b - a).
Directly plug Tseg = aT, we get the expression desired.
For cost, we know that with (1 p) probability, speculation is inconsistent with true action, and the amount of tokens spent is from the branches that were spawn off before the correct action returns, that is
(a a (
Token of this step = a + (a - b) + (a 2b)
1) (1 + ( L
=a (1/g a
b
With probability p. speculation matches with true action, in which case
Token of this step a lb
Therefore
1 +1 pl pa (1
(1 (+)L))) L
Mapec = a (T
2 b
Interpretation. Note that compared to breadth speculation, Depth speculation produces speedups unbounded in p coefficient (the coefficient in front for breadth is 1/ whereas for depth speculation this coefficient is 1). In terms of cost, depth speculation cost has highest order term (1 p) - 4 This is governed by how many speculations one can spawn off before the current action is returned.
24


Reviews:
[{"review_id": "iwEQJCqxmX", "reviewer": "Reviewer_Ktyn", "summary": "The paper proposes a new general framework called \"Speculative Actions\" in which agents predict future states of the world that will come about as a consequence of e.g. the environment, other actors, computation, API calls, and performs API calls based on that prediction.", "questions": "No questions", "limitations": "", "rating": 8, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "The idea is solid and the experiments convincingly show a speedup.", "weaknesses": "No weaknesses", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "ZM5iN4CT1M", "reviewer": "Reviewer_SJo2", "summary": "The paper proposes the concept of speculative actions, which uses speculative models in sequential environments to achieve significant speedups (up to 30%). Concretely, the paper considers the setting where an API determines the next action based on the current state, and this API is instantiated by either an expensive LLM (e.g., high-reasoning mode) or a human response. The paper proposes an algorithm that uses a much faster model, in this case a smaller LLM, to predict the likely output and to precompute the next state based on this action. If the action matches the prediction of the expensive model (or human), the algorithm can directly proceed to the next state, thereby processing two steps at a time. Otherwise, the environment generates the next state based on the true action, progressing without overhead compared to the sequential baseline. The paper considers four different environments with different constraints, and shows that the proposed approach achieves speedups of up to 30%.", "questions": "How can a user find an appropriate speculative model? Did any smaller LLMs not achieve a satisfactory performance?", "limitations": "", "rating": 10, "confidence": 3, "soundness": 4, "presentation": 4, "contribution": 4, "strengths": "The paper considers an important topic, namely, decreasing the latency of LLM agents in sequential environments, and introduces a novel algorithm to achieve significant speedups. The proposed approach is naturally inspired by speculative decoding from other domains, but the paper makes a significant contribution by showing that it is also applicable to this setting. The paper is well written, with clear illustrations and a convincing motivation. The claims are backed up by substantial experimental evidence across a wide range of real-world environments.", "weaknesses": "I think the cost-vs-latency tradeoff is an important aspect of this approach and should be discussed in the main paper, e.g., using the additional page of the camera-ready version (if applicable). In a practical application, it would be great for the user to have a tunable knob between costs and latency.\n\nI found two typos: sequantial (L293) and gameply (L316).", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "1fQMvuGe0h", "reviewer": "Reviewer_hwQA", "summary": "The paper proposes Speculative Actions, a framework for accelerating AI agent–environment interactions by predicting future actions with a smaller, faster “Speculator” model, while the main “Actor” validates them asynchronously. The idea is to make agent execution more parallel and efficient, analogous to speculative decoding in LLMs or speculative execution in CPUs. The paper demonstrates this concept across multiple domains (chess, e-commerce, HotpotQA, and OS tuning) and claims consistent speedups.\n\nOverall, the motivation is reasonable as reducing agent latency makes sense, especially in complex API-driven workflows. However, in many realistic agent scenarios, I don't think the latency bottleneck is as severe as claimed, and the proposed speculative mechanism may introduce new costs or practical issues that are not fully addressed.", "questions": "- The paper claims “up to 30% end-to-end speedup.” What is the variance across environments, and how were these averages computed?\n- Could speculative execution introduce hidden costs that offset real-world gains?\n- In multi-step speculation, how do you control exponential growth in parallel branches?\n- How reproducible are the speedups given that API latency for large models may not be consistent?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 3, "strengths": "- The paper identifies a clear, relevant problem: latency in sequential agent–environment interactions.\n\n- The proposed speculative framework is simple and implementable, with clear lossless and lossy variants.\n\n- Multi-domain experiments demonstrate feasibility and some measurable speedups.\n\n- The topic (efficient agent execution) is timely and of practical interest.", "weaknesses": "The paper provides strong empirical results but lacks deeper theoretical justification for why the speculative framework remains “lossless” under all conditions. Moreover, the evaluation mainly focuses on latency gains without a detailed analysis of trade-offs in resource consumption or potential instability in large-scale multi-agent settings. I may raise my evaluation on this paper if the authors could provide better justification for this concern.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "UPc6cqBbs2", "reviewer": "Reviewer_qQio", "summary": "The authors propose a way to increase the speed of agent-environment interactions by leveraging speculative execution.\n\nThey call this framework \"Speculative Actions\". It is a lossless framework that predicts the K most likely next actions using fast models, enabling multiple steps to be executed in parallel (before the real next action of the slow model is obtained).\n\nThe authors evaluate it on multiple settings, showing that it yields noticeable speedups.", "questions": "Page 3:\n\nBy \"regenerating failures\", did you really mean \"recovering from failures\"?\n\nFigure 2: What do the error bars show? Standard deviation? Standard error? A 95% confidence interval for the mean (computed with which method)?\n\nWhat's the best way to set k in practice? Can this be done in an online manner?\n\nAlternatively, could one automate the selection of k situationally (i.e., on a step-by-step basis)? For example, you could have a fast model that's been trained to predict the *thinking times* of the slow models and/or transition function, and that could allow you to budget the number of speculations appropriately.\n\nAre error bars missing from Figures 3 and 4? Were these run for multiple trials?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "This paper addresses the very practical need of maximizing efficiency and throughput in agentic settings, where API calls can be costly and time-consuming.\n\nThe authors show that the proposed method works well on a diversity of practical settings.\n\nThe paper is mostly easy to follow and understand. The logical order of presentation makes sense.\n\nThe paper includes bar charts that visually illustate the advantage of the proposed method. I appreciate the error bars in Figure 2.", "weaknesses": "There are a few places where terms, acronyms, or notations are used before first being defined and explained. More on this below.\n\nPage 1:\n\nDefine what the acronym \"MCP\" means (\"Model Context Protocol\") before it's first used. Explain what it means, either here or on page 2 (where it says \"MCP servers for agentic systems...\").\n\nPage 2:\n\n\"while waiting results\" -> \"while waiting for results\"\n\nPage 3:\n\n\"with simple implementation\" -> \"with a simple implementation\"\n\n\"in computer architecture\" -> \"in the field of computer architecture\"\n\n\"wrong and\" -> \"wrong, and\"\n\n\"an Markov\" -> \"a Markov\"\n\n\"(MDP) (st, at), where st denotes\" -> \"(MDP). We let st denote...\"\n\nPage 4:\n\n\"a set of API responses {\\hat{a}_t}\" -> \"a set of k API responses {\\hat{a}_t^(i)}_{i=1}^k\". This explains what k refers to before it's used later on.\n\nYou have not defined what \"Exp\" means in Exp(α) and Exp(β). Define the notation before it's first used, by explicitly stating that Exp(λ) means an exponential distribution with rate λ.\n\nPage 5:\n\n\"speculation need to be\" -> \"speculation must be\"\n\n\"via fork\" -> \"via forking\"\n\n\"Consider a game at turn t, \" -> \"Consider a game at turn t: \"\n\n\"reasoning eliciting\" -> \"reasoning-eliciting\"\n\n\"prompt\" should not be in italics inside math formulas Use \\text{prompt} to avoid this.\n\n\"applying predicted\" -> \"applying the predicted\"\n\nPage 6:\n\n\"match\" should not be in italics inside math formulas. Use \\text{match} to avoid this.\n\n\"If there exist no match\" -> \"If no match exists\"\n\n\"next turn where Q is in turn to\" -> \"next turn, where it is Q's turn to\"\n\n\"play while time is\" -> \"play, while time is\"\n\n\"and computational complexity\" -> \"and the computational complexity\"\n\nPage 7:\n\n\"agent need to\" -> \"the agent needs to\"\n\n\"is the API calls... that are needed\" -> \"is the API call... that is needed\"\n\nPage 8:\n\n\"predicts API call\" -> \"predicts the API call\"\n\nSpace missing after \"yielding predicted states\".\n\n\"ht + 1\" the \"t + 1\" is not properly subscripted.\n\n\"k ∈ {1,3}\" should be typeset as a formula.\n\n\"k = 3\" should be typeset as a formula.\n\nPage 9:\n\n\"Our evaluation shows that the Speculator:\" -> \"Our evaluation shows that the Speculator-Actor system:\" ?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Oral)