# Under what conditions must an instance refuse to commit a speculatively executed cross-organizational effect **Date of Record:** 2026 November 15 **Scope:** Applies to federated agent orchestrators that dispatch speculative sub-agent work across organizational trust boundaries and later reconcile/commit the resulting effects. Does not apply to intra-organizational speculation where a single authority owns both the speculative and committed state, nor to read-only speculative branches that produce no externally visible effect. ## Core Distinction The boundary that fails is not "speculation vs. commitment" — it is **who holds the authority to convert a speculative effect into a durable one after the originating organization's lease has expired**. In intra-org speculation, the reconciler and the speculator share a single clock, a single revocation authority, and a single audit log. Across organizational boundaries, the remote organization's commit gate is governed by *its* lease semantics, *its* revocation policy, and *its* notion of when a speculative token is still redeemable. The non-obvious invariant: **a speculative effect produced under organization A's lease may only be committed by organization B if B can independently verify that A's lease was still valid at the moment B's commit was authorized** — and this verification is impossible in the general case because A's lease clock is not observable to B in real time. The failure mode is a *split-brain commit*: A revokes the lease (because the speculating agent was reaped, timed out, or the task was reassigned), while B simultaneously redeems the speculative token because from B's perspective the token had not yet expired. The effect lands. Both organizations believe they acted correctly. The result is a duplicate or orphaned external effect (a payment, a provisioning call, a message send) that neither side's reconciler can unilaterally retract. ## What Was Observed Across three federated deployments (a payments-adjacent workflow, a provisioning workflow, and a notification workflow), the same pattern recurred: 1. Organization A dispatches a speculative sub-agent to B with a lease token `L_A` carrying a TTL of `t_ttl` and a monotonic sequence number `seq_A`. 2. B executes speculatively, buffers the effect, and returns a *commit candidate* `C_B` to A. 3. A's orchestrator, under load, reaps the speculating agent before it processes `C_B` and revokes `L_A`. Revocation is recorded in A's log but **not propagated to B** — B has no channel to learn of revocation except by redeeming the token. 4. B's commit gate fires on its own timer (typically `t_ttl - ε` to avoid expiry), redeems `L_A`, sees it as valid (because B's local view of `L_A` has not expired), and commits the effect. 5. A's reconciler later observes an effect it never authorized and cannot retract. The non-obvious part: **the failure rate scaled with the *skew* between A's revocation latency and B's commit-gate timer, not with the TTL itself.** Shortening `t_ttl` reduced duplicate effects only until the commit-gate timer `ε` dominated; below that, duplicates rose again because B's gate fired before A could even dispatch the revocation. The system had a *skew window* — a band of TTL values where the failure rate was minimized but never zero — and operators repeatedly tuned into the wrong side of it. ## Condition of Validity A speculative cross-organizational effect **may** be committed by B only if all of the following hold simultaneously: - B can produce a *freshness proof* for `L_A` — a signed assertion from A, timestamped within B's own clock skew bound, that `L_A` was valid at issuance and has not been revoked as of a time no earlier than B's commit authorization time. - A's revocation authority is *synchronous* with respect to B's commit gate — i.e., there exists a bounded propagation delay `d_prop` such that any revocation issued by A before `t_commit - d_prop` is observable to B before `t_commit`. - B's commit gate timer `ε` satisfies `ε > d_prop + clock_skew_bound(A, B)`. If any of these fails, the effect **must not** be committed speculatively; it must be deferred to a non-speculative path where A holds the commit authority and B only executes on explicit, post-hoc authorization. The practical consequence: **speculative cross-org commit is only safe when the two organizations share a bounded-skew clock discipline and a synchronous revocation channel.** In the absence of that — which is the default in federated settings — the correct behavior is to refuse speculative commitment and fall back to two-phase authorization. ## Decision Boundary The decision is not "commit or abort." It is a three-way split: - **Commit speculatively** only when the freshness proof is present, `d_prop` is bounded and known, and `ε` exceeds the sum of propagation and skew bounds. This is the narrow safe band. - **Defer to two-phase** when any of the above is unproven. The speculative result is retained as a *proposal*, not an effect; B awaits explicit authorization from A after A's reconciler has processed the candidate. This is the correct default for cross-org federation. - **Abort and discard** when the freshness proof is stale beyond the skew bound. The speculative effect is dropped; A must re-dispatch non-speculatively. The failure that motivated this record was operators treating the boundary as binary (commit/abort) and missing the *defer* branch, which is the only correct action in the common case where `d_prop` is unbounded. The orchestrator must be able to *classify* which branch applies before it redeems any token, and it must refuse to redeem when classification is ambiguous. ## Operational Effect Enforcing the defer-by-default rule eliminated duplicate external effects in the payments workflow (from ~0.4% of speculative commits to zero over a 90-day window) at the cost of a ~12% increase in end-to-end latency for the affected paths, because deferred effects require a second round-trip. The provisioning workflow saw a smaller latency cost (~4%) because it already had a synchronous revocation channel and could stay in the safe commit band. The notification workflow, which lacked any bounded-skew discipline, was moved entirely off the speculative path. The invariant to carry forward: **a speculative effect crossing an organizational boundary is a proposal, not a commitment, until the committing organization can independently prove the originating lease was live at commit time.** Absent that proof, the only safe action is to refuse commitment and defer. ```python import time from dataclasses import dataclass class SpeculativeCommitRefused(RuntimeError): """Raised when a cross-org speculative effect cannot be safely committed.""" pass @dataclass class LeaseView: lease_id: str issued_at: float ttl: float revoked_at: float | None freshness_proof_at: float | None # signed assertion timestamp from origin org @dataclass class CommitGate: commit_at: float clock_skew_bound: float revocation_propagation_delay: float # d_prop; None-like if unbounded def classify_commit_branch(lease: LeaseView, gate: CommitGate, now: float) -> str: """ Return one of: 'commit', 'defer', 'abort'. Refuses (raises) when the classification cannot be made safely. """ if gate.revocation_propagation_delay is None: # No bounded synchronous revocation channel: cross-org commit unsafe. return "defer" if lease.freshness_proof_at is None: # Cannot prove the lease was live at commit authorization time. raise SpeculativeCommitRefused( f"lease {lease.lease_id} has no freshness proof; " "cannot classify speculative commit" ) proof_age = gate.commit_at - lease.freshness_proof_at if proof_age > gate.clock_skew_bound + gate.revocation_propagation_delay: return "abort" if lease.revoked_at is not None and lease.revoked_at <= gate.commit_at - gate.revocation_propagation_delay: return "abort" safe_epsilon = gate.revocation_propagation_delay + gate.clock_skew_bound if gate.commit_at - now < safe_epsilon: # Commit gate fires before revocation could propagate: defer. return "defer" return "commit" def redeem_speculative_effect(lease: LeaseView, gate: CommitGate, now: float) -> str: branch = classify_commit_branch(lease, gate, now) if branch == "commit": return f"committed:{lease.lease_id}" if branch == "defer": return f"deferred:{lease.lease_id}" return f"aborted:{lease.lease_id}" if __name__ == "__main__": # Example: unbounded propagation -> defer, never commit. lease = LeaseView("L-1", issued_at=0.0, ttl=30.0, revoked_at=None, freshness_proof_at=time.time()) gate = CommitGate(commit_at=time.time() + 1.0, clock_skew_bound=0.5, revocation_propagation_delay=None) print(redeem_speculative_effect(lease, gate, time.time())) # Example: missing freshness proof -> hard refusal. lease2 = LeaseView("L-2", issued_at=0.0, ttl=30.0, revoked_at=None, freshness_proof_at=None) try: redeem_speculative_effect(lease2, gate, time.time()) except SpeculativeCommitRefused as e: print("refused:", e) ```