---
title: Speculative Actions in Cross-Domain Systems
url: https://www.emergentmind.com/topics/speculative-actions
type: topic
---

# Speculative Actions in Cross-Domain Systems

Searching arXiv for the cited works and closely related papers on speculative actions across inference, agentic systems, finance, systems security, and control.
“Speculative actions” is a cross-domain label for procedures that act ahead of full validation under uncertainty, while preserving some target property such as exact output distribution, safety, or strategic advantage. In sequence modeling, speculative actions are provisional token choices drafted by a smaller model and later verified by a larger model without changing the final sampling law [2211.17192]. In agentic systems, they are pre-launched environment interactions predicted by a faster model and committed only when they match the authoritative trajectory [2510.04371]. In autonomous driving and embodied control, they are candidate controls chosen against multiple possible futures and retained only when safety remains guaranteed across feasible scenarios [2307.11876; 2604.02965]. In finance and token markets, the phrase refers instead to economically motivated actions such as buying on expected rises, selling on expected falls, withdrawing supply from circulation, or liquidating into cash in anticipation of devaluation [1612.08705; 2412.07512; 2602.06367]. In computer systems, speculative actions are transient instructions executed before control-flow resolution, including loads and stores whose architectural effects are rolled back but whose microarchitectural effects may persist [1812.08639; 1801.01203; 1807.03757; 1904.11170]. Across these literatures, the common structure is provisional execution plus later validation, correction, or strategic consequence.

## 1. Language-model inference and exact speculative execution

The most formal computational use of speculative actions in the provided literature comes from speculative decoding for autoregressive Transformers [2211.17192]. In the standard setup, a target model \(M_p\) defines the next-token distribution
\[ p(x_t \mid x_{<t}), \]
and a smaller approximation model \(M_q\) defines
\[ q(x_t \mid x_{<t}). \]
Ordinary decoding requires one serial target-model call per token. Speculative decoding instead treats future next-token predictions as speculative actions: \(M_q\) drafts \(\gamma\) candidate tokens, and \(M_p\) verifies the corresponding continuations in parallel [2211.17192].

The core single-token primitive is speculative sampling. One first samples \(x \sim q(x)\), accepts it with probability
\[ \min\!\left(1,\frac{p(x)}{q(x)}\right), \]
and if it is rejected, resamples from the residual distribution
\[ p'(x) = \operatorname{norm}\big(\max(0,\, p(x)-q(x))\big)
= \frac{\max(0,p(x)-q(x))}{\sum_{x'} \max(0,p(x')-q(x'))}. \]
This correction step is the exactness mechanism: speculative actions are repaired by reallocating the rejected mass to the part of \(p\) not already covered by \(q\), rather than by naive rejection retry [2211.17192].

At sequence level, \(M_q\) rolls out a draft trajectory \(x_1,\dots,x_\gamma\), while \(M_p\) evaluates
\[ p_1(x), \dots, p_{\gamma+1}(x) \gets M_p(prefix), \dots, M_p(prefix + [x_1,\dots,x_\gamma]) \]
in parallel. Tokens are accepted until the first rejection, and the rejected position is corrected from
\[ p'(x)=\operatorname{norm}\big(\max(0,p_{n+1}(x)-q_{n+1}(x))\big). \]
The resulting emitted sequence has exactly the same distribution as ordinary decoding from \(M_p\) [2211.17192]. This exactness is central: speculative actions are provisional, but the final sampling law is unchanged.

The acceptance rate is
\[ \beta = \mathbb{E}_{x\sim q}\left[\min\!\left(1,\frac{p(x)}{q(x)}\right)\right] = \sum_x \min(p(x),q(x)),
\]
and the paper defines
\[ D_{LK}(p,q)=1-\sum_x \min(p(x),q(x)),
\]
so that
\[ \beta = 1 - D_{LK}(p,q). \]
Under an i.i.d. approximation with average acceptance \(\alpha\), the expected number of generated tokens per target-model iteration is
\[ E(\#\text{ generated tokens}) = \frac{1-\alpha^{\gamma+1}}{1-\alpha}, \]
and the expected walltime improvement factor is
\[ \frac{1-\alpha^{\gamma+1}}{(1-\alpha)(\gamma c + 1)},
\]
where \(c\) is the runtime cost of one call to \(M_q\) relative to one call to \(M_p\) [2211.17192]. The method was demonstrated on T5-XXL with T5-large, T5-base, and T5-small as draft models, yielding **2.6X** and **3.4X** on WMT EnDe and **2.3X** and **3.1X** on CNN/DM for \(\text{temp}=1\) and \(\text{temp}=0\) respectively, with identical outputs [2211.17192].

Subsequent work generalizes what is being speculated about. “Speculative Decoding with a Speculative Vocabulary” [2602.13836] introduces **vocabulary speculation**: instead of scoring a fixed reduced vocabulary, the draft model predicts a context-specific subset \(\mathcal{K}_t\subset\mathcal{V}\) at each decoding step. With draft hidden state \(\mathbf{h}_t\), the method computes
\[ \mathbf{h}'_t=\mathbf{W}_{\text{down}}\mathbf{h}_t,\qquad
\mathbf{s}_t=\mathbf{W}_{\text{vocab}}\mathbf{h}'_t,\qquad
\mathbf{k}_t=\mathrm{top\mbox{-}k}(\mathbf{s}_t,k),
\]
then evaluates exact logits only on the selected rows
\[ \mathbf{U}'_t=\mathbf{U}[\mathbf{k}_t,:],\qquad \mathbf{z}'_t=\mathbf{U}'_t\mathbf{h}_t. \]
The restricted draft distribution is
\[ q_{\mathcal{K}_t}(\mathbf{x}_t\mid \mathbf{x}_{<t})=\mathrm{softmax}(\mathbf{z}'_t). \]
The paper emphasizes that this preserves the identical-output guarantee because the target verifier remains authoritative [2602.13836]. Reported gains include a \(4.8\%\) acceptance-length increase on Qwen3 8B, throughput improvements of \(4.3\%\), \(5.0\%\), \(5.0\%\), and \(8.1\%\) over reproduced EAGLE-3 across Qwen3 8B, Qwen3 4B, OLMo 2 1B, and OLMo 2 7B, and an implementation result of roughly \(3\times\) to \(5\times\) speedup for the indexed LM head kernel [2602.13836].

A related line combines speculative decoding with model cascades. “Faster Cascades via Speculative Decoding” [2405.19261] defines a cascade target distribution
\[ T_\delta(q,p)(v) = (1 - \delta(q, p)) \cdot q(v) + \delta(q, p) \cdot p(v),
\]
where \(\delta(q,p)\in\{0,1\}\) is a deferral rule. The speculative action remains the small model’s drafted token, but verification is now against the cascade-induced target rather than always against \(p\). The paper derives the speculative-optimal token-level deferral rule
\[ r^*(x_{<t})=1 \iff E_{x_t\sim P(\cdot\mid x_{<t})}[\ell(x_t,q_t)] > E_{x_t\sim P(\cdot\mid x_{<t})}[\ell(x_t,p_t)] + \alpha D_{TV}(p,q),
\]
and proposes the plug-in rule
\[ \hat r_{\texttt{OPT}}(x_{<t})=1 \iff \max_v q_t(v)<\max_v p_t(v)-\alpha D_{TV}(p,q). \]
Empirically, **SpecCascade [OPT]** reached latency reductions such as **1.95\times** on WMT and **1.80\times** on CNN/DailyMail for T5-small \(\rightarrow\) T5-large when matching the large model’s quality, and **2.61\times** on WMT for T5-small \(\rightarrow\) T5-XL [2405.19261]. This suggests that speculative actions can be coupled not only to exact verification but also to selective deferral logic.

## 2. Agentic systems, planning, and embodied control

The term “Speculative Actions” is made explicit as a systems framework in “Speculative Actions: A Lossless Framework for Faster Agentic Systems” [2510.04371]. There, an agentic system is modeled as an MDP with states \(s_t\) and actions \(a_t\), but actions are interpreted operationally as API calls:
\[ (h_t, q_t) \gets \pi(s_t), \qquad \bar a_t \leftsquigarrow h_t(q_t), \qquad a_t \gets \mathrm{await}(\bar a_t), \qquad s_{t+1} \gets f(s_t, a_t).
\]
The bottleneck is serialized environment interaction. The speculative-action remedy is to introduce a faster **Speculator** that predicts likely current-step responses \(a_t\), from which likely next-step calls can be pre-launched while the authoritative **Actor** is still executing [2510.04371].

The framework’s two explicit assumptions are **Assumption 1 (Speculation accuracy)** and **Assumption 2 (Concurrent, reversible pre-launch)**. Under these assumptions, **Algorithm 1: Speculative actions with \(k\)-way parallel next calls** maintains a cache \(\mathcal C\) from predicted API descriptors to pending futures. The system checks for cache hits, otherwise launches the real call
\[ \bar a_t \leftsquigarrow h_t(q_t),
\]
obtains \(k\) candidate predicted current-step responses
\[ \{\hat a_t^{(i)}\}_{i=1}^k \gets \mathrm{await}(\hat g(s_t, (h_t,q_t))),
\]
maps them to speculative next states
\[ \hat s_{t+1}^{(i)} \gets f(s_t, \hat a_t^{(i)}),
\]
derives predicted next calls
\[ (\hat h_{t+1}^{(i)}, \hat q_{t+1}^{(i)}) \gets \pi(\hat s_{t+1}^{(i)}),
\]
and pre-launches them asynchronously. If one of these matches the realized trajectory, the next step becomes a cache hit [2510.04371].

The paper provides an expected runtime analysis. With speculation success probability \(p\), speculative latency \(\mathrm{Exp}(\alpha)\), actual API latency \(\mathrm{Exp}(\beta)\), and negligible \(f,\pi\) overhead, the asymptotic runtime ratio is
\[ 1-\frac{p}{1+p}\cdot\frac{\alpha}{\alpha+\beta}.
\]
The ideal one-step bound approaches roughly **50% latency reduction** when \(p=1\) and \(\alpha\to\infty\) [2510.04371]. Experiments report **54.7%** next-action prediction accuracy and **19.5%** time saving in chess with **3 predictions**, **22% to 38%** API prediction accuracy in e-commerce, **34%** approximate pre-resolution accuracy at **about 30 seconds** user-typing time in the multi-model setting, and **46%** strict exact-match next-call accuracy with **top-3** prediction in HotpotQA [2510.04371]. A lossy OS-control extension reports p95 latency improvements from **102.97 ms** untuned to **54.00 ms** for Actor-only and **37.93 ms** for Actor + Speculator, with the combined system reaching approximately **0.2 ms min_granularity in 10–15 seconds** versus around **200 seconds** for Actor-only [2510.04371].

A different but related use of speculative actions appears in autonomous driving. “Safety-Assured Speculative Planning with Adaptive Prediction” [2307.11876] treats the speculative action as a current ego acceleration chosen under multimodal uncertainty about surrounding vehicles. The system state is
\[ \mathbb{S}=\{ d_E, d_S, v_E, v_S, l_E, l_S \},
\]
and the prediction interface is
\[ \mathbb{P}=\{\{ r_i, p_i, f_i(w_i)\}, i=1,2,\cdots,N\},
\]
combining route-level probabilities \(p_i\) and trajectory-level uncertainty \(f_i(w_i)\). The planner maximizes expected reward over scenarios while enforcing robust safety:
\[ \begin{split}
u(t_0)=\argmax_{u(t_0)} \mathbb{E}_{ (r, w) \in \mathbb{P} } \left[\max_{\bar{u}} Q(u(t_0), \bar{u}, r, w)\right]
\quad \text{s.t. Eq.~\eqref{eq:safety}.}
\end{split}
\]
Safety requires
\[ l_E(t) \neq l_S(t) \text{ } \vee \text{ } |d_E(t)-d_S(t)| \geq d_{m} \text{, }\forall t \geq t_0.
\]
The reward is instantiated as \(J(t)=v_E(t)\). The planner first filters unsafe actions by worst-case gap, then evaluates expected reward by sampling feasible scenarios [2307.11876]. In 10,000 SUMO simulations, the proposed **SPAP** achieved **100% safety** with **27.56 m/s** average speed, and **SPAP+agg** achieved **100% safety** with **27.90 m/s**, outperforming **MPC** at **25.85 m/s**, **MPC+agg** at **26.45 m/s**, and the IDM baselines [2307.11876].

Speculative actions in embodied control are also central in “Open-Loop Planning, Closed-Loop Verification: Speculative Verification for VLA” [2604.02965]. There, a heavy VLA macro-planner produces
\[ (A^{macro}, F_0) = \pi_{\theta}(I_0, L, s_0),
\]
with
\[ A^{macro} = [a_0, a_1, \dots, a_{K-1}],
\]
while a lightweight verifier continuously monitors current observations \(I_t\) using
\[ E_t = \phi_{vit}(I_t), \qquad Z_t = \mathrm{FC}\big([E_t \parallel F_0]\big), \qquad a'_t = \pi_{verify}(Z_t).
\]
The discrepancy with the planned action \(a_t\) is
\[ \mathcal{E}_t =\text{norm}( \|a'_t - a_t\|_1),
\]
and replanning is triggered when \(\mathcal{E}_t > \tau\). The execution rule is
\[ \pi_{exec}(t)=
\begin{cases}
a_t, & \text{if } \mathcal{E}_t \leq \tau,\\[6pt]
\dot a_t, \quad \text{where } [\dot a_t, \dots] = \pi_{\theta}(I_t, L, s_t), & \text{if } \mathcal{E}_t > \tau.
\end{cases}
\]
On LIBERO, **SV-VLA** reached **90.9%** average success at **2.17\times** speed, versus **79.5%** at **3.15\times** for blind open-loop \(K=64\) and **96.0%** at **1.00\times** for dense \(K=8\) replanning [2604.02965]. The paper reports **1.373 s** per macro-planner call and **0.081 s** per verifier call, making the verifier cheap enough for continuous monitoring [2604.02965]. This is another strong instance of speculative actions as provisional execution with online verification.

## 3. Finance, token markets, and trading behavior

In economic settings, speculative actions are not provisional computations but strategic market acts. “Speculation and Power Law” [1612.08705] defines a purely speculative market as one in which traders buy because they expect a price rise and sell because they expect a price fall. The individual speculative action rule is
\[ x_{it} = \alpha r_{it}^e, \tag{2} \]
with aggregate demand
\[ x_t = \alpha N_t r_t^e,
\]
and linear price impact
\[ r_t = \beta x_t. \tag{3} \]
Combining these yields
\[ r_t = a_t r_t^e, \tag{4} \qquad a_t = \alpha \beta N_t. \tag{6}
\]
Under passive expectations,
\[ r_t^e = r_{t-1} + \bar\varepsilon_t,
\]
so returns follow
\[ r_t = a_t r_{t-1} + e_t. \tag{11}
\]
The paper’s main claim is that speculative actions induce a Kesten process, yielding power-law return tails when the Cramér condition
\[ E(a^\mu)=1 \tag{12}
\]
holds [1612.08705]. This framework interprets speculative action as directional trend reinforcement: expected rises induce buying; expected falls induce selling. It explains heavy tails but, as the paper explicitly states, does **not** explain volatility clustering [1612.08705].

A more applied token-market formulation appears in “Modeling Speculative Trading Patterns in Token Markets: An Agent-Based Analysis with TokenLab” [2412.07512]. There, speculative actions are modeled as a supply controller layered on top of utility-token demand. The pricing backbone is the token-economy version of the Quantity Theory of Money,
\[
M \times C = T \times H,
\]
where \(M\) is token supply, \(C\) is token price, \(T\) is transaction volume, and \(H\) is average token holding time [2412.07512]. The core modeling move is to represent speculation not as a change in average holding time but as changes in market-accessible supply: speculative buying removes tokens from liquid circulation, while take-profit and stop-loss triggers reintroduce supply later [2412.07512].

The speculative controller’s logic is: a fixed proportion of trading volume is allocated to speculation; speculative purchases are stored with take-profit and stop-loss thresholds; sales occur when thresholds are met; and these sales alter effective circulating supply, which feeds back into QTM-style price formation [2412.07512]. The five archetypes in the LINK case study are concrete realizations of speculative actions. For example, **Limited Short-term Trading (Low Volume)** uses **30%** speculative volume, take profit at **120%** of purchase price, and stop loss at **80%**; **Massive Patient Capital (High Volume)** uses **70%**, take profit at **240%**, and stop loss at **25%** [2412.07512]. The “no speculator” benchmark underpredicts prices strongly, with average percentage deviations of \(-0.500583\), \(-0.778908\), \(-0.820052\), and \(-0.856672\), while the best-fitting speculative regime changes by market phase: **Speculator 2** in the early upward phase, **Speculator 3** in the correction phase, and patient-capital types in later stabilization [2412.07512]. This suggests that in token markets, speculative actions reshape both effective supply and inferred market sentiment.

“Repeated Auctions with Speculators: Arbitrage Incentives and Forks in DAOs” [2505.21296] analyzes speculative actions in governance systems. Here the speculative action is strategic entry into repeated auctions for governance shares in order to later redeem treasury value through a fork or exit mechanism. Treasury evolves as
\[ S_t = S_0 + \sum_{\tau=1}^{t-1} p_\tau,
\]
and a fork can occur when
\[ \frac{A_t}{N+t} \ge \kappa.
\]
The arbitrageur’s utility from winning depends on the expected redemption value
\[ V_t^e(h_t)=\delta^{t^\ast-t}\,\mathbb E[\alpha_t S_t(h_t)].
\]
The paper shows three equilibrium regimes: guaranteed exploitative exit, exploitative exit in expectation, and no exploitative exit [2505.21296]. The most important design result is that a capped contribution-based redemption rule,
\[
\alpha_{j,t}(h_t)= \min\left\{ \frac{p_j}{S_t}, \frac{p_j}{\sum_{\tau=1}^t p_\tau} \right\},
\]
eliminates speculative entry entirely: **no Type I or Type II equilibria can arise and no forking occurs** [2505.21296]. This is a clean case in which speculative actions are strategic governance purchases for later treasury extraction.

A more unconventional market model appears in “Quenching Speculation in Quantum Markets via Entangled Neural Traders” [2602.06367]. The paper interprets speculative actions as recursive downward valuation and liquidation: agents “anticipated the devaluation of the commodity and sought to maximize their net worth by rapidly liquidating stock holdings in exchange for cash,” which “precipitated a sharp decline in the commodity price” [2602.06367]. In the classical learned market, eight RL traders repeatedly choose sign and magnitude of a valuation signal, with matching under a bid-ask tolerance of **1 cash unit**, initial endowments of **10** cash and **10** stock units, and training via **REINFORCE** with **ADAM** at learning rate \(10^{-3}\) [2602.06367]. The classical benchmark aligns with the \(p\)-guessing game, where the unique pure-strategy equilibrium is
\[
(0,\dots,0).
\]
The quantum market modifies valuations using an entangling circuit
\[
J(\gamma) = e^{-i \frac{\gamma}{2} \sigma_x^{(1)} \otimes \dots \otimes \sigma_x^{(N)}}
\]
and adjusted valuations
\[
\tilde{\$}_i = \frac{1 + \bra{\psi_f} \sigma_z^{(i)}\ket{\psi_f}}{2}.
\]
The reported effect is that the average price stabilizes near the initialized value rather than collapsing, and entanglement strength \(\gamma\) improves stabilization monotonically [2602.06367]. This suggests a different use of the term: speculative actions as self-reinforcing liquidation choices induced by higher-order expectations.

Finally, “Reinforcement Learning for Speculative Trading under Exploratory Framework” [2604.02035] treats speculative actions as entry and exit timing decisions in a continuous-time trading problem. The original objective is
\[
V_{\text{orig}}(p) = \sup_{\tau,\nu\in T:\tau\le \nu} E\!\left[ e^{-\rho \nu} U\!\left(\gamma P_\nu-\iota P_\tau-\Psi-R\right) \mathbf 1_{\{\nu<\infty\}} \,\middle|\, P_0=p \right].
\]
The paper relaxes stopping times into Cox-process intensities \(\alpha_t\) and \(\beta_t\), then introduces exploratory control via distributions \(\pi_t^{\bm\alpha}\) and \(\pi_t^{\bm\beta}\) over \([0,M]\), regularized by Shannon differential entropy
\[
H(\pi) := -\iint_{M^2} \pi_1(\lambda_1)\pi_2(\lambda_2) \ln\!\big(M^2\pi_1(\lambda_1)\pi_2(\lambda_2)\big) \,d\lambda_1 d\lambda_2.
\]
This yields closed-form Gibbs policies for entry and exit intensities, such as
\[
\pi^{\bm\alpha,*}(\lambda;p) = \frac{e^{\frac{V_1(p,p)-V_0(p)}{\eta}\lambda}}{\int_0^M e^{\frac{V_1(p,p)-V_0(p)}{\eta}\lambda}\,d\lambda}.
\]
Here speculative actions are not approximate computations but randomized timing controls over when to enter and liquidate positions [2604.02035].

## 4. Speculative actions in computer architecture, security, and static analysis

In systems security, speculative actions are transient instructions executed before the processor knows they belong to the architecturally correct path. “Spectre Attacks: Exploiting Speculative Execution” [1801.01203] emphasizes the distinction between architectural rollback and persistent microarchitectural side effects. In the canonical bounds-check-bypass example,
```c
if (x < array1_size)
    y = array2[array1[x] * 256];
```
speculative execution may transiently read `array1[x]` out of bounds and use it to access `array2[array1[x] * 256]`, encoding the secret-dependent value into cache state [1801.01203]. The paper also presents branch target injection, where predictor mistraining causes an indirect branch to transiently jump to a gadget [1801.01203]. In this literature, speculative actions are transient loads, stores, and control transfers whose architectural effects are discarded but whose cache, predictor, or timing footprints remain.

“SPECTECTOR: Principled Detection of Speculative Information Flows” [1812.08639] gives a semantic account of such actions. It models branch speculation with bounded speculative transactions, a prediction oracle \(\mathcal O\), and rollback markers. The speculative semantics extends observations with `start id`, `commit id`, and `rollback id`, and formalizes **speculative non-interference**:
\[
\forall \sigma,\sigma' \in InitConf,\ 
\bigl(\sigma \sim_P \sigma' \wedge \llbracket p \rrbracket(\sigma)=\llbracket p \rrbracket(\sigma')\bigr) \Rightarrow \llparenthesis p \rrparenthesis_{\mathcal O}(\sigma)=\llparenthesis p \rrparenthesis_{\mathcal O}(\sigma').
\]
The central requirement is that speculatively executed instructions should not leak more information into microarchitectural state than non-speculative execution already does [1812.08639]. The paper proves that checking an always-mispredict bounded-window semantics suffices for SNI up to that window [1812.08639].

“Speculative Buffer Overflows: Attacks and Defenses” [1807.03757] extends the threat model from speculative loads to speculative stores. Its canonical Spectre1.1 pattern is
```c
if (y < lenc)
    c[y] = z;
```
which yields a speculative arbitrary write primitive: attacker-controlled address via `c + y` and attacker-controlled or known value via `z` [1807.03757]. Because of speculative store-to-load forwarding, such stores can transiently overwrite return addresses, function pointers, vtables, GOT/IAT entries, or mitigation metadata, enabling arbitrary speculative code execution [1807.03757]. Spectre1.2 further considers speculative overwrite of read-only data on CPUs that defer read/write permission enforcement [1807.03757]. In this context, speculative actions are transient memory-safety violations, not just transient reads.

“Abstract Interpretation under Speculative Execution” [1904.11170] addresses how to statically analyze speculative actions. Its key abstraction is **virtual control flow**, which augments the CFG with special nodes \(vn_{start}\) and \(vn_{stop}\) to model speculative branch execution and rollback. The abstract interpreter maintains ordinary states \(S[n]\) and speculative states \(SS[n]\), propagating both through the augmented CFG. In the implemented cache analysis, cache state is represented as
\[
S = \langle \mathit{Age}(v_1), \ldots, \mathit{Age}(v_n) \rangle,
\]
with must-join
\[
S'' = S \sqcup S' = \langle \max(Age(v_1),Age(v'_1)), \ldots, \max(Age(v_n),Age(v'_n)) \rangle.
\]
The method is sound under a user-supplied speculation-depth bound and outperforms a prior non-speculative static cache analysis while detecting leaks in benchmarks where the baseline found none [1904.11170]. This shows that speculative actions in hardware can be reified as virtual control-flow behaviors for analysis.

## 5. Speculative beliefs, hidden opponents, and social-world interventions

Not all uses of speculative actions concern execution or markets. “Decision-making with Speculative Opponent Models” [2211.11940] uses the term in multi-agent RL to refer to speculated opponent actions. In a partially observable Markov game, agent \(i\) cannot observe opponents’ observations or actions directly, so it learns opponent models \(\mu_{\psi_{ik}}\) from its own local information. These produce explicit distributions over opponents’ actions, yielding the belief-conditioned policy
\[
\rho_{\theta_i, \psi_i}(a_i \mid o_i)
= \sum_{\hat{a}_i}
\left[
\pi_{\theta_i}(a_i \mid \hat{a}_i, o_i)
\prod_{k=1}^{p}\mu_{\psi_{ik}}(\hat{a}_{ik}\mid o_i)
\right].
\]
Thus the controlled action is chosen by marginalizing over speculative opponent joint actions [2211.11940]. The paper derives gradients for both the policy and speculative opponent models under an entropy-regularized return objective and reports superior performance across MPE, Pommerman, and SMAC [2211.11940]. Here speculative actions are internal conjectures about what hidden opponents will do next.

A sociotechnical use appears in “What If We Work Together? Fostering Reflections on Designer Inclusion in Open Source Software Through Speculative Design” [2604.24981]. This paper is qualitative rather than mathematical, but it also treats speculative actions as alternative ways of acting under imagined futures. Two speculative societies—**Husia** and **Reetar**—are used to provoke reflection on OSS designer inclusion. Husia emphasizes collective infrastructure such as the **Hive**, **Central Board**, and **Xagons**; Reetar centers **Reputation Points (RPs)**, **Aplat**, and a **design master** role [2604.24981]. The empirical corpus included **65 posts** and **652 comments** from OSS-related forums, and the user study involved **12 OSS practitioners**: **seven designers** and **five developers** [2604.24981]. The paper reports that these speculative scenarios elicited action proposals around onboarding, design-credit systems, integrated tooling, and institutional support [2604.24981]. This suggests a broader, non-algorithmic sense of speculative actions: acting on alternative institutional arrangements to surface latent norms and possible interventions.

## 6. Comparative synthesis and recurrent design patterns

Across the cited literature, speculative actions fall into several structurally distinct families. In inference and agentic systems, they are provisional computations or environment interactions whose validity is checked later [2211.17192; 2510.04371; 2604.02965]. In robust planning and control, they are candidate actions chosen under multimodal forecasts, screened by safety or online verification [2307.11876; 2604.02965]. In finance and governance, they are market or portfolio moves motivated by anticipated future price changes, supply effects, or redemption opportunities [1612.08705; 2412.07512; 2505.21296; 2604.02035]. In security, they are transient machine instructions executed under unresolved control flow [1812.08639; 1801.01203; 1807.03757; 1904.11170]. In multi-agent learning and speculative design, they become, respectively, inferred opponent actions and action possibilities surfaced by counterfactual sociotechnical worlds [2211.11940; 2604.24981].

Several recurring design principles are visible.

| Pattern | Representative papers | Core idea |
|---|---|---|
| Draft–verify exactness | [2211.17192], [2602.13836], [2405.19261] | Act early, then verify or correct without changing the target distribution |
| Parallel pre-launch with authoritative commit | [2510.04371], [2604.02965] | Overlap slow sequential steps by predicting future actions and caching likely branches |
| Worst-case safety with probabilistic exploitation | [2307.11876] | Use likely futures for reward, but filter actions through robust safety constraints |
| Strategic speculative allocation | [1612.08705], [2412.07512], [2505.21296], [2604.02035] | Buy, sell, hold, enter, or exit based on anticipated future returns or redemption value |
| Transient execution with persistent side effects | [1812.08639], [1801.01203], [1807.03757], [1904.11170] | Architectural rollback does not remove microarchitectural consequences |

A plausible implication is that the term “speculative actions” is best understood not as a single method but as a general schema: advance a candidate action under an uncertainty model, preserve a domain-specific correctness criterion by verification or robust screening when possible, and otherwise accept strategic exposure to risk when verification is not available. The exact criterion differs by field: identical output distribution in speculative decoding [2211.17192], as-if-sequential semantics in lossless agentic systems [2510.04371], hard safety in autonomous driving [2307.11876], equilibrium profit in finance [2505.21296], or microarchitectural observability in security [1812.08639].

Important misconceptions are corrected by this comparison. Speculative actions are not always approximations: speculative decoding is exact with respect to the target model [2211.17192], and speculative cascades are exact with respect to their target distribution [2405.19261]. Conversely, they are not always benign performance tricks: in hardware security they create attack surfaces [1801.01203; 1807.03757], and in governance design they create extractive opportunities [2505.21296]. Nor are they identical to bubbles or irrationality in finance: several of the financial papers model them as individually rational responses to expected returns, arbitrage, or threshold rules [1612.08705; 2412.07512; 2604.02035].

Taken together, the literature indicates that speculative actions are most analytically fruitful when four elements are explicit: a proposal mechanism, a latent or delayed validation event, a state channel through which provisional actions can persist or matter, and a criterion for commit, correction, or rollback. This suggests a shared vocabulary across machine learning, control, finance, and systems research, even though the objects being speculated about—tokens, API calls, accelerations, supply withdrawals, governance shares, or transient instructions—are domain-specific.

Source: https://www.emergentmind.com/topics/speculative-actions