Skip to main content
Status: Final
Normative-dependency status: single-validator launch and a static genesis multi-validator network (Mode B) require no dynamic validator-set reconfiguration. They do consume the consensus beacon interface for runner-selection seeding (§9.2): M == 1 jobs select immediately in submission block S using the parent beacon R_{S-1}, while M > 1 jobs are recorded in S and selected via commit-then-reveal from the seed of an absolute future round r_seed = advance_round(r_submit, K) (§9.2). Multi-validator transport/identity checks consume a genesis-anchored ValidatorSetSnapshot(0) (§5.4). What is gated on a full consensus-layer validator-set-reconfiguration primitive — which no accepted CIP defines (it is whitepaper/commonware-owned, §5.4/§17) — is dynamic validator-set changes over time (E → E+1: epoch advance + BLS threshold resharing/DKG emitting new snapshots). Mode A additionally requires the §5.4 validator-identity snapshot and Mode-A certificate state/instructions; with a static genesis set it can use ValidatorSetSnapshot(0) and does not require dynamic reconfiguration. These interfaces are not fully wired into Cowboy execution today; “Final” reflects the design being settled, not that every MUST is immediately implemented (§5.4, §17).
Type: Standards Track
Category: Core
Created: 2026-04-14
Requires: CIP-2, CIP-13 v2 (effective_stake is normative on the VRF / Fisher-Yates weight base used by §9). CIP-11 also consumes two consensus/execution interfaces: (1) execution-readable consensus beacons/seeds for runner-selection seeding (§9.2) — the parent beacon R_{S-1} for immediate M == 1 selection, and verified threshold seeds by absolute round (notarization, finalization, and nullification certificates) for commit-then-reveal M > 1 selection (each consumed seed is committed in the assignment block — §9.2 consumed-seed commitment) — and (2) an execution-readable ValidatorSetSnapshot(epoch) containing validator Ed25519 peer identities (§5.4). CIP-11 amends CIP-2 §5/§10 for runner-selection seed timing/domain separation (cowboy-runner-select-v3:). For a static genesis validator set, ValidatorSetSnapshot(0) can be genesis-anchored and does not require epoch advancement or BLS threshold resharing. For dynamic validator-set changes over time (E → E+1), the consensus integration must additionally expose the validator-set reconfiguration primitive (epoch advancement + BLS threshold resharing/DKG) that emits new snapshots. Consensus, epochs, and the validator-set lifecycle are owned by the technical whitepaper (§“Consensus and Networking”, §“Validator Set”) and the commonware consensus engine — not by any CIP; CIP-11 defines only the execution-readable interfaces it consumes (§5.4).
Cowboy Cloud and Cowboy Chain. This CIP specifies the Cowboy protocol. Cowboy Cloud runs on this protocol today. Cowboy Chain, a public network on the same protocol, is under consideration for a future release. Where the two differ, this CIP says so.
Revision history
  • r1.6 (2026-11-11). Validators push CIP-10 workload hints to subscribed workload hosts (§6.7). Peers negotiate the minor version, and this revision is 0x0101 (§12.3).
  • Room session lifetime (2026-10-22). A room session opened by a wake lives at most its route’s session_limits.lifetime_blocks and never past its signed template’s expiry. A provider closes its own idle or unserved room sessions (§15.9).
  • Regenesis amendment (2026-10-07). MRU reads and writes are unconditional from genesis, and expired records are reclaimed with terminal jobs (§9.4).
  • r1.5 (2026-10-11). The validator paces heartbeat pings (§6.3). Native session reports travel on the control stream (§10.3). The reference runner’s on-chain heartbeat defaults to 45 s (§6.6).
  • r1.4 (2026-10-09). Push is the only delivery and result path (§10.1, §10.3, §14).
  • r1.3.1 (2026-08-18). The MRU write path excludes both runners_to_slash and runners_unrewarded (§9.4).
  • r1.3 (2026-06-06). Presence became a mode-aware, consensus-visible PresenceInput (§2.1, §7, §8). The wire format gained role-scheme identity binding and explicit signature domains (§6.2, §12.6).
  • r1.2 (2026-05-26). Block time aligned to 1 s, and every _BLOCKS constant was rescaled by a factor of 5.
  • r1.1 (2026-05-11). The §9.3 weight base uses CIP-13 v2 effective_stake.
  • v0.2 (2026-04-14). Canonicalization, MRU and dispatch-outcome review findings.

1. Abstract

Background

Runners poll for jobs under CIP-2 §3.

Goal

This CIP specifies push delivery over persistent QUIC connections. Each runner connects to a deterministically chosen subset of validators. Selection uses real-time runner presence to route jobs first to runners marked reachable and accepting, then corrects for unreachable selections (§8, §11).

Overview

CIP-11 keeps the CIP-2 §4–§5 selection algorithm and adds:
  1. Each runner holds long-lived, mutually authenticated QUIC streams to a fixed-size, deterministically assigned subset of validators (§5, §6).
  2. The on-chain Job Dispatcher reads PresenceInput, a consensus-visible per-block input, to draw the runner committee present-first (§7). By default the proposer supplies it as a best-effort, fail-open hint (§8.1, §8.2). An opt-in hard-exclude mode derives it from consensus-verified certificates instead (§8.3). The dispatcher reads it at the same point in every mode.
  3. Validators with a live stream to a selected runner push the JobAssignment; the runner acknowledges, executes, and streams the result back (§10).
  4. The most-recently-successful runner for (submitter, job_kind) is favored on the first draw, improving cache locality (§9).
Presence affects selection but fails open. Selection draws present runners first and routes push to them. The eligibility floor remains the runner’s own on-chain heartbeat (CIP-2 Part I §4), and presence never excludes a heartbeat-eligible runner (§7.3). For multi-validator Mode B jobs with verification.runners > 1, the VRF draws committee membership over the full floor-eligible set, and presence only routes delivery (§7.3, §16.9). The ack timeout and fallback path correct a false presence signal after the first attempt (§11).
  • Push replaces polling as the only job delivery path. Dispatch latency drops from ~poll_interval to block inclusion, application and one RTT, about 1–2 s at 1 s blocks (§10.1).
  • Selection prefers connected runners and pushes to them immediately. A stale or false presence signal adds at most a bounded first-attempt delay and never fails a job (§7.3).
  • A single-validator launch needs only a committed PresenceInput block field, the dispatcher read-point and the §9.2 consensus-seed plumbing. Multi-validator Mode B keeps the same field, which the proposer fills from off-chain validator gossip. Only a changing validator set needs the reconfiguration mechanism (§5.4), and only opt-in Mode A changes where PresenceInput comes from (§8.3).
  • In default Mode B, presence cannot make a floor-eligible runner ineligible, because the floor is canonical chain state that no validator can forge or directly clear (§7.1, §7.3). A proposer can still deny a specific runner work in its own slots by suppressing it when the present pool is full, and proposer rotation bounds that (§16.2, §16.9). Mode A gives up this guarantee for strict exclusion (§8.3).
  • Runner identity, stake and capabilities stay in the Runner Registry (0x0000…0001), and results settle through the existing CIP-2 commit-reveal path (§10.3).

2. Motivation

Under CIP-2 alone, the runner side works as follows:
  1. The Job Dispatcher (0x0000…0002) selects M runners on-chain via stake-weighted Fisher-Yates over the registered candidate set and writes each assignment to runner_jobs_key(addr).
  2. Each runner separately polls GET /runner/{addr}/jobs over plain HTTP every job_poll_interval_seconds.
  3. When the runner has a result, it POSTs to /runner/{addr}/job_result (multi-runner jobs first POST /runner/{addr}/job_result_commit). The validator builds the corresponding transaction and forwards it to the mempool.
  4. Polling latency is the floor on job start time. A multi-second poll interval is a large fraction of the budget for short interactive jobs (LLM completions, single MCP calls); driving it lower wastes bandwidth across thousands of runners.
  5. Selection does not consult real-time reachability. The dispatcher selects only Healthy runners, and the Runner Registry marks a runner Unhealthy once last_heartbeat is stale. That signal is coarse. A runner that dies after its last heartbeat is still assigned, times out and forces re-selection, which costs several blocks on every silent failure.
  6. Heartbeats cost on-chain bandwidth. About 1,000 runners today, and 5,000 at the §6.6 design target, each post a periodic heartbeat transaction.
  7. Pull-based delivery cannot prefer the runner that most recently served an actor, which would improve cache locality.
CIP-11 addresses (1) with push, (2) with present-first selection (§7) and ack-timeout correction (§11), and (4) with the MRU bias (§9). It partially addresses (3). Because push and ack provide fast liveness, governance MAY widen the heartbeat cadence (§14). The heartbeat stays as the eligibility floor (§16.2).

2.1 Why presence is a mode-aware artifact, not a vote bitmap

r1.2 tried to recover presence from per-validator bitmaps attached to finalization votes. That design is infeasible for one structural reason, and two gaps in the current stack also block it. Threshold-aggregated votes carry no per-validator payload. Consensus uses commonware Simplex with BLS12-381 threshold signatures. A finalized block stores one assembled Finalization { proposal, certificate }. Assembly recovers a single threshold signature from the individual contributions and discards them. The whitepaper’s QC model keeps at most a signer_bitmap of which validators signed, and the commonware certificate keeps no membership bitmap at all. Neither has room for a per-validator application payload such as a presence observation. Adding one would change the consensus vote and certificate format, which the technical whitepaper and commonware own (§17). Two further gaps block the read-back path in the current stack:
  1. The validator set is not execution-readable. It is hardcoded in consensus configuration (EPOCH = 0, no reconfiguration), and no validator system instruction exists, so the state-transition function cannot verify a validator-origin attestation.
  2. Execution cannot read parent votes. Block execution receives only the block and receipts, and the finalization proof never reaches execution.
Both gaps can be built. §5.4 defines the execution-readable ValidatorSetSnapshot(epoch) that the first gap lacks, and opt-in Mode A (§8.3) verifies validator-origin attestations against it. Closing the gaps does not revive the vote-bitmap design, because aggregation has already destroyed the per-validator payload. Mode A works because it carries presence evidence separately from the aggregated finalize signature. Presence evidence therefore needs its own consensus-visible artifact, which differs by validator-set size:
  • One validator (launch): the lone validator observes every runner’s connection first-hand and states presence as a block input. This needs no registry, threshold or consensus change beyond the input field (§8.1).
  • Many validators: the default path keeps proposer-supplied, best-effort presence, which needs no new consensus mechanism because it fails open (§7.3). Validator identities come from the §5.4 ValidatorSetSnapshot. Only opt-in Mode A adds per-validator evidence, verified against that snapshot and enabled only by governance (§8.3).

3. Definitions, Notation, and Conventions

3.1 Requirements language

The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, MAY, OPTIONAL are to be interpreted as described in RFC 2119 and RFC 8174 when, and only when, they appear in all capitals. Lowercase uses carry their ordinary English meaning. Unless a requirement is explicitly scoped to a narrower topology or mode, normative requirements apply in every topology/mode in which the referenced component is active. Where presence-selection behavior differs by posture, unqualified presence-selection text describes Mode B, the default posture; Mode A requirements are explicitly marked (§8.3–§8.4).

3.2 Notation

  • H: a block height; H−1 its parent, H+1 its child; current_block_height is the height being executed.
  • E, E+1: consecutive active validator-set snapshot epochs; subset_epoch is the active ValidatorSetSnapshot.epoch value (§5.3–§5.4), not a separate per-consensus-epoch tick.
  • V: the active validator set (snapshot, §5.4); n = |V|; f, the BFT fault bound (f < n/3).
  • R: a runner; |R|, the number of registered runners.
  • Sub(R) / Sub_E(R): runner R’s connectivity subset (in epoch E); k = |Sub(R)|.
  • M: the committee size for a job (= job_spec.verification.runners); i, the zero-based weighted-draw iteration (§9.2).
  • S: a job’s submission block height; for M > 1, the committee is assigned at a later pending-selection pass once the absolute seed round r_seed is readable (§9.2).
  • Round(e, v): the consensus round identified by commonware Seed.round = (epoch, view). A block height is not a round: a block at height S is proposed in one absolute round and can be certified/finalized in a later absolute round. Runner-selection randomness MUST name the absolute Round(e, v) whose seed is consumed (§9.2).
  • R_X: a consensus threshold-VRF beacon/seed for round/anchor X (e.g. parent beacon R_{S-1}, absolute seed round r_seed); see canonical_seed_bytes (§9.2).
  • multi_validator: the predicate n = |V| > 1 (more than one active validator in the §5.4 snapshot); distinguishes the multi-validator security paths from the single-validator launch case (f = 0).
  • ‖: byte concatenation; keccak256(...), the Keccak-256 hash.

3.3 Defined terms

  • Connectivity Subset (Sub(R)): The deterministic, fixed-size set of validators runner R maintains QUIC connections to, computed off-chain from the active validator-set snapshot (§5). Bounds connection fan-out; under one validator it is that validator.
  • Selection Liveness Floor (a.k.a. the eligibility floor, the on-chain heartbeat floor, or just floor): The on-chain heartbeat-derived eligibility gate the dispatcher applies: a candidate is eligible iff HealthStatus::Healthy and current_block_height − last_heartbeat ≤ HEARTBEAT_TIMEOUT_BLOCKS. The runner attests it on-chain. In Mode B it is the only eligibility gate. In Mode A, presence is an additional gate on top of the floor (§7.1, §7.3, §8.3).
  • Selection posture, Mode B and Mode A (opt-in): The two postures for how PresenceInput affects selection. Mode B is the default in all topologies: presence orders the draw and routes delivery but never removes a floor-eligible runner (§7.3, §8.2). Mode A is the opt-in hard-exclude posture, gated by PRESENCE_HARD_EXCLUDE_ENABLED, in which a runner not proven present is not selectable (§8.3, §8.4). Unless stated otherwise, the spec describes Mode B.
  • Present-first selection: Drawing the committee from the present pool first and from the fallback pool only once the present pool is exhausted (§7.3, §9.2). In multi-validator Mode B it does not determine membership for runners > 1 jobs (§7.3, §16.9).
  • Fail-open: The Mode B property that a missing, stale, malformed or false PresenceInput can never fail a job or exclude a floor-eligible runner. At worst it wastes one delivery attempt (caught within ACK_TIMEOUT_BLOCKS) or moves a runner to the fallback pool (§7.3).
  • Best-effort (presence): In Mode B, PresenceInput is an ordering and routing hint without Byzantine verification. Its failure modes are bounded and self-healing (§8.2, §16.2).
  • PresenceInput: The deterministic, consensus-visible per-block artifact the Job Dispatcher reads to identify currently-present runners (a bitmap/index set over the Runner Registry). Same execution read-point in all modes; its source and validation are mode-aware (§7.2, §8).
  • Present pool / fallback pool: At selection, the present pool is the set of eligible candidates marked present by PresenceInput; the fallback pool is the remaining eligible candidates. Selection draws present-first, falling back only as needed (§7.3).
  • Local Presence: A single validator’s off-chain, per-connection view of which runners it currently has a healthy QUIC control stream to. Used to route its own push delivery; it is also the source of that validator’s contribution to PresenceInput (§7.4).
  • Consensus-Verified Presence State (Mode A only): presence_proven_until[runner], maintained on-chain by verified runner-submitted presence certificates (§8.3); the source of PresenceInput only when the opt-in hard-exclude Mode A is enabled.
  • Push Dispatch: A validator opening a QUIC stream to a runner and writing a JobAssignment, the only way a runner receives a job (§10).
  • MRU Weight Multiplier: A deterministic iteration-0 weight bump for the most-recently-successful runner for (submitter, job_kind) (§9.3).
  • Dispatch Outcome: Success | Duplicate | SoftFailure | HardFailure, a validator’s classification of a push attempt (§10.6).
  • Runner identity: a runner’s registered Address in RunnerRegistration (20-byte secp256k1/EVM address). RunnerRegistration does not store a secp256k1 public key; runner-originated CIP-11 frames carry a scheme-tagged compressed secp256k1 PubKey and/or a recoverable secp256k1 signature, and verifiers MUST derive/recover the EVM address and require it to equal RunnerRegistration.address. This address is the runner’s economic identity and the authority for runner-originated control-plane frames.
  • Validator peer identity: the Ed25519 commonware identity key a validator uses for network peer identification and to sign validator-originated CIP-11 control-plane frames, asymmetric to the runner’s secp256k1 identity. The BLS12-381 threshold key is consensus-only (notarization) and is never used for control-plane signatures (§2.1, §12.6).
  • Scheme-tagged key / role-scheme signature: The signer’s role determines how verifiers interpret public-key and signature fields. A runner uses secp256k1 (33-byte key, 65-byte recoverable ECDSA sig). A validator uses Ed25519 (32-byte key, 64-byte sig). Keys carry a 1-byte scheme tag and signed preimages include role + scheme; verifiers MUST reject any role/scheme/length/source mismatch (§12.6). Two key types appear in this spec: PubKey is the wire type, a scheme-tagged key (scheme_id ‖ key_bytes; 34 B secp256k1 / 33 B Ed25519) used in CIP-11 frames and receipts (§12.6); PublicKey is the raw commonware Ed25519 key type used for authoritative §5.4 snapshot state (ValidatorRecord.peer_pubkey). A validator wire PubKey MUST decode (after scheme validation and tag-strip) to the authoritative raw ValidatorRecord.peer_pubkey; a runner wire PubKey MUST be valid secp256k1 key material whose derived EVM address equals the authoritative RunnerRegistration.address.
  • validator_set_hash: keccak256 over the active §5.4 ValidatorSetSnapshot’s ordered validator identities (peer_pubkey per ValidatorRecord, excluding the mutable stake), at launch, the genesis single-validator snapshot. Identifies the shared validator-set configuration (§5.1, §5.4, §6.2).
  • Proposer: The validator that authors the current block. Under one validator it is always that validator; in Mode B it supplies PresenceInput in the block it proposes (§8.1–§8.2).
  • Committee: The set of M = job_spec.verification.runners runners the Job Dispatcher selects for a job (§9.2).
  • On-chain system actors: the Runner Registry (0x0000…0001), stores runner identity, stake, RunnerCapabilities, HealthStatus, and last_heartbeat; the Job Dispatcher (0x0000…0002), runs selection and writes assignments and mru_key; the Result Verifier (0x0000…0003), processes commit/reveal, finalizes results, and produces/consumes VerifiedResult.runners_to_slash. CIP-2 introduces these actors and selection concepts; CIP-11 extends their behavior but adds no new actor in the normative path.
  • subset_epoch: The epoch value of the active ValidatorSetSnapshot(epoch) consumed by CIP-11. It is not a separate CIP-11 counter and does not advance on every consensus epoch tick; it changes only when consensus emits a new CIP-11-visible validator-identity snapshot whose canonical ordered peer_pubkey list changes (§5.4). It selects which snapshot Sub(R) / validator_set_hash are computed against (§5.3–§5.4).
  • mru_key / MruRecord: Job Dispatcher state mapping (submitter, job_kind) → MruRecord { runner_address, set_at_block }, the most-recently-successful runner used for the §9.3 iteration-0 weight bump (§9.4).
  • presence_anchor (Mode A): per-runner state holding the observation height of the newest accepted presence certificate; the strictly-monotonic anchor that bounds receipt replay (§8.3).
  • CIP-11 wire frames: the runner-validator QUIC messages defined in §6 and §10 and tabulated in §12.2. HeartbeatPing / HeartbeatPong are the QUIC-layer liveness frames, distinct from the on-chain heartbeat that drives the floor (§7.1).
  • channel_binding / connection_id: channel_binding is the TLS-Exporter value that binds application-layer role-scheme identity proofs (runner secp256k1 / validator Ed25519) to a specific QUIC/TLS channel (§6.2); connection_id = keccak256(...) is the per-connection identifier derived from it plus the peer identities and epoch (§12.6). Both appear in frame signature preimages and are the reason HeartbeatPong is not chain-verifiable (§8.3).
  • Reconfiguration & Mode-A objects (defined where introduced, listed here for discoverability): ValidatorSetSnapshot / ValidatorSetActivated, the consensus interface CIP-11 consumes (§5.4); ValidatorRecord, a snapshot entry (§8.3); PresenceReceipt and the SubmitPresenceCertificate system instruction, Mode-A presence evidence (§8.3); OverlapExpired, a GoodbyeReason for reconfiguration teardown (§5.3, §12.5).
  • Imported terms (defined in other CIPs; used here normatively):
    • RunnerRegistration, RunnerCapabilities, HealthStatus (Healthy / Unhealthy / Paused / Deregistered), and last_heartbeat, live Runner Registry record and fields. CIP-2 §4 owns the health-filter concept; CIP-11 consumes it as the floor (§7.1).
    • JobSpec, JobType, VerificationMode (None, EconomicBond, MajorityVote, StructuredMatch, Deterministic, SemanticSimilarity), job/verification shapes (CIP-2); JobSpec.verification.runners = M.
    • runners_to_slash, VerifiedResult.runners_to_slash, produced by the Result Verifier for minority/mismatch runners and consumed by the verifier and aggregator to exclude dissenters from consensus-matching completion/bonus selection; not a CIP-2-defined type.
    • effective_stake = registration.stake + delegation_totals.total_active, VRF weight base (CIP-13 v2 §3.2; mirrored by CIP-2 concentration math).
    • CapabilityKey (CIP-11-local string key for advisory capability deltas using the runtime RunnerCapabilities / dispatcher-filter namespace) and EntitlementId ([u8; 32]; CIP-2), runner advisory capability and pool/entitlement identifiers. Storage and secret capability semantics remain owned by CIP-9/CIP-24.
    • Fisher-Yates VRF selection, commit-reveal settlement, timeout-based re-selection, the CIP-2 §4–§6 mechanisms CIP-11 extends.
    • keccak256, secp256k1 (ECDSA with ecrecover), QUIC (RFC 9000), TLS 1.3 (RFC 8446) and its TLS-Exporter, standard helpers used across Cowboy.
    • Address, a Cowboy chain account address; PublicKey, the commonware Ed25519 consensus/peer participant key type (the validator peer identity above). Runner wire public keys are secp256k1 PubKeys authenticated by derived-address equality against RunnerRegistration.address.
    • Frame codec: CIP-11 runner-validator wire frames are QUIC application frames with the envelope defined in §12.1. Payloads use CIP-11’s deterministic CBOR profile (§12.6). commonware-codec applies only where a field explicitly names an existing codec-owned object, e.g. tx_bytes = Transaction::write(...) (§10.3).
    • SystemInstruction::{RunnerHeartbeat, JobSubmit, JobResultSubmit, JobResultCommit, JobCancel}, live system-instruction variants; SubmitPresenceCertificate is the new Mode-A system instruction this CIP specifies, to be added to the same namespace when Mode A is implemented.
    • Transaction::signing_hash() / signing_preimage(), the shared release-codec signing boundary (§10.3). In the current wallet-identity release, the digest is Keccak-256 of the full ordered Transaction::write bytes with every signature zeroed and all signer addresses retained; this binds the chain ID, nonce, instruction, all limits/fees, metadata and deferred fields. CIP-11 result and heartbeat transaction replay protection relies on this ordinary transaction signature/nonce path unless this CIP explicitly defines a separate application-frame nonce.
    • execution_hash() / extra_data, block identity fields/functions. Because PresenceInput affects dispatcher output, it MUST be committed in the execution identity / block digest (§7.2).
    • selection_reputation_x1e9(runner.reputation, ReputationConfig_at(H), H), the live dispatcher reputation normalizer used by the CIP-2 v3 selection weight; ReputationConfig is the governance-updatable config type.

4. Design Overview

4.1 Architecture

4.2 Lifecycle

  1. Bootstrap. Runner reads the configured validator set, computes validator_set_hash and Sub(R) (§5), and opens a long-lived QUIC connection to each validator in Sub(R) (the sole validator, at launch).
  2. Handshake. Mutually authenticated, channel-bound, pubkey-bound handshake on each connection (§6.2).
  3. Heartbeat (two layers). On the QUIC control stream the runner MUST emit HeartbeatPing at least once every HEARTBEAT_BLOCKS (default: once per block); the validator MUST update per-connection liveness and local presence for each valid Ping, subject to the backpressure omission rule (§6.4). Independently, the runner submits the on-chain heartbeat that maintains its canonical last_heartbeat/health, the eligibility floor (§7.1).
  4. Presence input. The dispatcher reads a PresenceInput that names currently present runners (§7.2). By default the proposer supplies it in the block (§8.1, §8.2). Mode A derives it from consensus-verified certificate state (§8.3).
  5. Selection. The Job Dispatcher filters by the eligibility floor (§7.1) and runs the weighted VRF draw present-first with the MRU iteration-0 bias (§9). runners == 1 jobs select immediately in submission block S from the parent beacon R_{S-1}. runners > 1 jobs record a pending selection in S and are assigned once S is finalized and the seed for the future round r_seed is readable (§9.2). In multi-validator Mode B, runners > 1 membership ignores presence (§7.3).
  6. Push dispatch (after finalization & application). Once the assignment block is finalized and applied, validators holding a live stream to the selected runner push a fully-covered, signed JobAssignment (§10.1); the runner dedupes and verifies before executing.
  7. Result. Runner streams the existing commit/reveal material back (§10.3); the validator forwards the existing CIP-2 transaction(s); settlement is unchanged.
  8. MRU update. The Result Verifier deterministically picks the winning runner and updates mru_key (§9.4).
  9. Re-selection. If no result by the per-job timeout, the existing CIP-2 §6 timeout re-selection runs (§11.2).

4.3 Relationship to Existing CIPs

  • CIP-2. CIP-11 strictly extends CIP-2: candidate list, Fisher-Yates VRF, commit-reveal verification, and timeout re-selection are preserved. Push replaces polling for job delivery (§14). The on-chain heartbeat health gate becomes the codified eligibility floor (§7.1).
  • CIP-9. Push reduces cold-start before CBFS reads; MRU bias improves read-cache hit rates.
  • CIP-10. Lower job-start latency reduces idle container cost; base images SHOULD ship the CIP-11 client transport. A workload host learns of new and updated workloads in its host pools through pushed wp: hints (CIP-10 §17.3, §6.7).
  • CIP-13. Delegated stake is opaque to CIP-11; CIP-13 supplies the effective_stake stake term consumed by the CIP-2 v3 VRF weight (§9.3).
  • CIP-15. A runner_route entry in an actor’s routes table carries a §15 RouteDeclaration; CIP-15 §6.9 installs the table and the §15.3 sponsorship ceiling.

5. Connectivity Subset Assignment

Each runner connects to a deterministic subset of the validators in the consensus-provided snapshot (§5.4). At launch the subset is the sole validator. In Mode B the subset is an off-chain routing and DoS-bounding rule with no on-chain state. Mode A checks subset membership in execution when it verifies certificates (§8.3). Every participant computes the subset from the same snapshot, so all agree without coordination.

5.1 Subset Function

Let V = [v_1, ..., v_n] be the active validator-set snapshot’s participants (§5.4), ordered canonically, and R.auth_pubkey the runner’s address-authenticated compressed secp256k1 public key. validator_set_hash = keccak256 over the snapshot’s ordered validator identities (peer_pubkey per ValidatorRecord; excluding the mutable stake, §8.3). R.auth_pubkey is not stored in RunnerRegistration; it is accepted only when the secp256k1 key is valid and its derived EVM address equals RunnerRegistration.address. v.peer_pubkey is the validator’s Ed25519 peer identity from its ValidatorRecord (§8.3). The subset is keyed on those:
Defaults MIN_SUBSET = 3, MAX_SUBSET = 8. The outer min(|V|, …) keeps the subset within the validator set: |V| = 1 (launch) gives k = 1 (the sole validator for every runner); |V| = 2 ⇒ k = 2. Above the floor the clamp governs: |V| ∈ [5,8] ⇒ k = 4, |V| ∈ [9,16] ⇒ k = 5, saturating at MAX_SUBSET = 8 for large |V| (e.g. |V| = 100 ⇒ k = 8). Mode A needs a larger k (§8.4).

5.2 Properties

  • Stable under runner churn. A new runner’s subset is independent of others’.
  • Load-balanced in expectation. Each validator handles |R|·k/|V| connections in expectation.
  • Validator-side DoS gate. A validator MUST reject connections from a runner not in that runner’s expected Sub(R) for the validator’s own identity, a purely local check bounding Sybil storms to k connections per registered identity (§16.1). Hint-only connections of bound slots are bounded per host instead (§6.7).

5.3 Subset Epochs and Reconfiguration

Sub(R) is computed from the active validator-set snapshot for the current subset_epoch (§5.4). subset_epoch is constant within an epoch and increments only on a consensus validator-set change, never per block or per runner-registry mutation, so Sub(R) and validator_set_hash are stable for an epoch’s life and connections do not thrash. Single validator (launch). The snapshot is the degenerate epoch-0 set of size 1: subset_epoch = 0, validator_set_hash constant, Sub(R) = the sole validator. No rotation occurs; the rules below are inert until a second epoch exists. Reconfiguration (epoch E → E+1). When consensus signals ValidatorSetActivated(E+1, activation_height) (§5.4), every node recomputes Sub_{E+1}(R) and validator_set_hash(E+1) from the new snapshot. To avoid a presence/delivery gap at the boundary, an OVERLAP_BLOCKS window (default 160, §13) runs from activation_height:
  1. Connections. Runners MUST open connections to Sub_{E+1}(R) while keeping Sub_E(R) open, i.e. maintain the union Sub_E(R) ∪ Sub_{E+1}(R) for the window, then drop epoch-E-only validators.
  2. Admission (§6.2), epoch-paired, never cross-product. A connection is valid iff (offered hash == validator_set_hash(E) and this validator ∈ Sub_E(runner)) OR (offered hash == validator_set_hash(E+1) and this validator ∈ Sub_{E+1}(runner)). The offered (subset_epoch, validator_set_hash) selects exactly one snapshot; the validator’s peer_pubkey and its subset membership MUST both resolve in that same snapshot. The union Sub_E(R) ∪ Sub_{E+1}(R) is only the set of connections that are valid at the same time. Mixing epoch E’s hash with epoch E+1 membership would break the connection_id and HelloAck identity binding. The runner applies the same epoch-paired rule when verifying the validator.
  3. Routing & presence. A validator routes/attests for a runner only over an epoch-paired-valid connection (point 2); in Mode A, a PresenceReceipt counts only if its own (subset_epoch, validator_set_hash) is epoch E or E+1 and the signing validator is in Sub_epoch(runner) (where epoch is E or E+1 as selected by the offered (subset_epoch, validator_set_hash)) (§8.3).
  4. After the window (at block activation_height + OVERLAP_BLOCKS, a height-tied cutoff identical for all nodes, no grace period): only Sub_{E+1}(R), validator_set_hash(E+1), and epoch-E+1 receipts are valid. Either side MAY initiate closing an epoch-E-only connection (one whose validator is not in Sub_{E+1}(R)) with Goodbye { reason: OverlapExpired } (§12.5); the peer abandons in-flight work on that stream (it drains via §11.5) and MUST NOT reconnect under the epoch-E hash. A Hello offering validator_set_hash(E) past the cutoff is rejected at §6.2 admission.
The consensus integration decides when to emit a new snapshot, at consensus epoch boundaries (§5.4). CIP-11 defines no emission cadence or churn threshold. Its transport reacts to an emitted ValidatorSetActivated and never advances subset_epoch itself. In-flight jobs that cross the boundary drain per §11.5.

5.4 Validator-Set Snapshot (Consensus Interface)

CIP-11 does not define validator-set reconfiguration. The consensus layer agrees on the next validator set, performs BLS threshold-key resharing/DKG, and advances epochs (see Requires). CIP-11 instead consumes a consensus-provided, execution-readable interface:
Snapshot retirement is derived from the successor ValidatorSetActivated event plus the OVERLAP_BLOCKS reaction window (§5.3); CIP-11 does not consume a separate retirement_height field. The field names above are CIP-11’s proposed consumption contract; a future consensus integration that emits this interface must match them (or CIP-11 adapts to the consensus-side names). For every block, CIP-11 subset_epoch MUST equal the epoch field of the active ValidatorSetSnapshot. A consensus epoch advance that does not change the canonical ordered validator peer-identity list MUST NOT emit a CIP-11 ValidatorSetActivated, MUST NOT change subset_epoch, and MUST NOT change validator_set_hash. Pure stake changes, threshold-key resharing with the same peer-identity set, or other consensus metadata changes are not CIP-11 subset reconfigurations unless the ordered peer_pubkey list changes. Each ValidatorRecord carries { peer_pubkey, stake } (§8.3), where peer_pubkey is the validator’s Ed25519 commonware peer identity (§3) and stake is not consumed by any CIP-11 rule (carried for consensus / other-CIP use); validator_set_hash(epoch) is keccak256 over the epoch’s ordered peer_pubkeys (excluding stake). This snapshot is everything CIP-11 needs to recompute Sub(R), validator_set_hash, QUIC admission, and overlap behavior, and (Mode A) to verify validator control-plane signatures. The consensus side additionally owns the ordered participants, the group polynomial, local share delivery, and threshold-identity continuity across the reshare, none of which CIP-11 specifies. The validator-identity snapshot and dynamic reconfiguration are separate dependencies:
  • Validator identity snapshot: execution reads a canonical list of validator identities, ValidatorSetSnapshot(epoch) with ordered Ed25519 peer_pubkeys. A static genesis topology needs only ValidatorSetSnapshot(0), derived from the genesis participant configuration. Multi-validator Sub(R), validator_set_hash, QUIC admission, JobAssignment.validator_pubkey verification and Mode-A receipt verification all use it. Cowboy does not yet expose it as execution state.
  • Dynamic validator-set reconfiguration: changing the set over time (E → E+1) needs the consensus mechanism named in Requires. Cowboy runs at epoch 0 and does not consume it.
Static Mode B works without the snapshot on-chain, because proposer-supplied PresenceInput fails open and selection verifies no validator-origin certificates. Static Mode A needs the snapshot and the Mode-A certificate state, but no epoch advancement or resharing. CIP-11’s reconfiguration behavior is fully specified (§5.3, §6.2, §8.3, §11.5) and activates once snapshots advance past epoch 0.

6. The QUIC Connection Layer

6.1 Transport

QUIC (RFC 9000) with TLS 1.3; reference impl MAY use quinn. Each connection carries one control stream (bidirectional, id 0) for the connection lifetime and zero or more validator-initiated job streams (one per assignment). QUIC connection migration absorbs network changes without re-handshake.

6.2 Handshake and Authentication

TLS 1.3 provides encryption and integrity. Certificates MAY be self-signed and use any algorithm the stack supports, because the TLS certificate key is not the CIP-11 identity. Each party proves its identity at the application layer by signing a control-plane transcript bound to the TLS channel with its role key: secp256k1 for the runner, the Ed25519 peer key for the validator (§3):
Implementations MUST verify, under the chosen QUIC/TLS stack (quinn/rustls, RFC 8446 §7.5 exporters), that channel_binding bytes are connection-specific, stable only within the authenticated session, and unavailable to a TLS-terminating proxy, before relying on the §6.2 MITM/proxy-replay resistance. A stack that cannot provide exporter bytes with those properties is not conforming for CIP-11 mutual authentication. Both sides exchange Hello, then HelloAck:
HelloAck.signed_challenge signs the peer’s challenge_nonce together with chain_id, version, both roles, both pubkeys, subset_epoch, validator_set_hash, and channel_binding (§12.6), binding the on-chain identity to this specific channel and preventing MITM/proxy replay. Admission: the runner party_pubkey MUST be a valid secp256k1 wire PubKey whose derived EVM address resolves to a RunnerRegistration with health != Deregistered, or, on a connection negotiated at 0x0101 or above, to a bound slot whose host’s registration qualifies (hint-only admission, §6.7); the validator MUST verify its own identity is in Sub(runner.auth_pubkey) for the shared validator_set_hash; the runner MUST verify the validator pubkey is in the active validator-set snapshot (§5.4). A chain_id mismatch is fatal (Goodbye, §12.5). For validator_set_hash: outside a reconfiguration overlap, a mismatch is fatal; during an OVERLAP_BLOCKS window (§5.3) admission is epoch-paired. The offered (subset_epoch, validator_set_hash) MUST select exactly one snapshot (epoch E or E+1), this validator’s peer_pubkey MUST resolve in that snapshot, and this validator MUST be in Sub_epoch(runner) (where epoch is E or E+1 as selected by the offered (subset_epoch, validator_set_hash)). Mixing one epoch’s hash with the other epoch’s membership is rejected. Both proofs MUST verify before admission; before that, a validator MUST NOT apply DoS accounting, record local presence, or push jobs. Validators MUST rate-limit unauthenticated Hello per peer. Hello.block_height and HelloAck.block_height are advisory telemetry for debugging, progress display, and stale-peer heuristics only. They are not part of the HelloAck signed preimage (§12.6), do not define receipt or assignment freshness, and MUST NOT be used as an admission, rejection, or slashing criterion. Freshness for signed objects MUST use the object-specific signed heights/windows (PresenceReceipt.block_height, assignment_height, deadline_block). In every mode, the validator Ed25519 private key corresponding to ValidatorSetSnapshot.peer_pubkey is a validator-node control-plane signing key. It MUST remain inside the validator-node signing boundary and MUST NOT be exported to runner-facing helpers, relay processes, presence-gossip aggregators, or sidecars. In this revision every validator-originated CIP-11 application signature (HelloAck, HeartbeatPong, PresenceReceipt, JobAssignment, JobCancel, authenticated Goodbye) is verified against that snapshotted peer_pubkey. A future delegated control key is valid only if the delegation is itself execution-readable and epoch-bound: the active/overlap validator snapshot, or a consensus-owned authorization attached to it, MUST bind the delegated key to (subset_epoch, validator_set_hash, peer_pubkey) before nodes or execution accept signatures under it.

6.3 Heartbeats

The runner MUST send HeartbeatPing at least once every HEARTBEAT_BLOCKS (default 1) on a new block height. The validator MUST answer a Ping whose block_height is at or above its finalized head only once that head has passed it, and answers a Ping at an older height at once; the HeartbeatPong.block_height is the validator’s head when it answers. A runner that sends each Ping at the previous Pong’s block_height (the first at the validator Hello’s) therefore pings once per finalized block with no block-height read of its own. On each valid Ping the validator MUST update the runner’s per-connection liveness state and MUST record/refresh the runner in local presence (§7.4), unless §6.4 currently requires omitting it because the runner is not accepting new work; a runner silent for PRESENCE_TIMEOUT_BLOCKS (default 15) is dropped from that validator’s local presence. The Ping nonce MUST be strictly increasing within a single connection (nonce[i+1] > nonce[i]); the runner MUST reject a HeartbeatPong whose nonce_echo does not equal the most-recent outstanding Ping’s nonce, and the validator MUST sign nonce_echo (anti-replay). The nonce is per-connection: on a new connection (initial handshake or reconnect) it restarts at 0. Because every HeartbeatPing signature is bound to connection_id (§12.6), which includes the fresh per-connection channel_binding, a Ping from one connection cannot be replayed on another even after the counter resets; a validator that loses nonce state on restart re-learns it from the next Ping on the new connection. Mode A uses a separate, chain-verifiable PresenceReceipt instead (§8.3).
The QUIC heartbeat feeds local presence (and, in multi-validator mode, presence evidence). The eligibility floor used by selection is the separate on-chain heartbeat (§7.1).

6.4 Backpressure

When accepting_new = false, validators MUST remove the runner from local presence (§7.4), which stops push routing (§10.1) and removes it from the validator’s local-presence contribution to PresenceInput, and MUST set accepting_new = false in any HeartbeatPong (§6.3) / PresenceReceipt (§8.3) for it until it re-asserts capacity (a BackpressureSignal with accepting_new = true, or a fresh handshake, restores the entry on the next valid HeartbeatPing, §6.3). A runner that has signaled it cannot accept work is therefore not drawn present-first. In Mode B this affects ordering and routing only. To leave Mode-B selection entirely, a runner must let its on-chain health lapse or deregister. Under Mode A (§8.3), accepting_new = false receipts do not count toward t_hard, so backpressure prevents the runner from obtaining or refreshing consensus-verified presence; once any previously accepted presence_proven_until no longer covers the selection block, the runner is not selectable while still backpressured. Immediate Mode-A exclusion on backpressure would need a separate on-chain clearing rule. “Present” therefore means reachable and accepting work.

6.5 Capability and Entitlement Updates

CapabilityDelta is transport-advisory only and MUST NOT mutate the on-chain RunnerRegistration; durable capability changes still require the registry path. CapabilityKey is a CIP-11-local canonical UTF-8 key drawn from the runtime RunnerCapabilities / dispatcher-filter namespace (for example RunnerCapabilities.job_types values and boolean/structured capability fields). EntitlementId remains the existing [u8; 32] entitlement identifier. A validator MAY apply a delta locally to avoid pushing a job the runner cannot currently serve.

6.6 Operational Considerations (single validator, ~5,000 runners)

The launch topology is one validator and up to a few thousand runners. Implementations MUST account for these tuning requirements:
  • Connection count. With k = 1 the sole validator holds one QUIC connection per runner (≈ |R|, ≈5,000 at target scale). Operators MUST raise file-descriptor limits (e.g. ulimit -n ≥ 2× runner count) and budget connection-state memory (~0.5–1 MB/connection). QUIC connection migration (§6.1) avoids reconnect storms on transient network changes.
  • Pre-auth flood resistance. The §6.2 per-peer Hello rate limit and the §5.2 subset DoS gate together bound connection-storm cost; operators SHOULD additionally cap concurrent half-open handshakes and accept-queue depth, since the subset gate only rejects after the peer’s claimed identity is known.
  • On-chain heartbeat volume. At ~5,000 runners, on-chain heartbeat volume depends on cadence as well as timeout. The “tens per block” target assumes an effective on-chain cadence near the HEARTBEAT_TIMEOUT_BLOCKS window (default 100 blocks) and staggered runner phases: 5,000 / 100 ≈ 50 heartbeat transactions per block. The reference runner defaults to a 45 s cadence (RUNNER_HEARTBEAT_INTERVAL_SECONDS), which is about 45 blocks at the default 1 s block time and therefore yields 5,000 / 45 ≈ 111 heartbeat transactions per block before launch, restart, or partition-heal bursts. Governance MAY widen HEARTBEAT_TIMEOUT_BLOCKS and the effective runner heartbeat cadence (§14), since push/ack provides the fast-liveness signal, while preserving a floor-safety margin before staleness. The QUIC HeartbeatPing (§6.3) is off-chain and uses no block space.
  • Heartbeat staggering. Runner implementations SHOULD decorrelate on-chain heartbeat submissions with a deterministic per-runner phase bucket. Define safety_margin_blocks large enough for normal inclusion/finality delay, bounded jitter, and expected short mempool congestion; define effective_cadence_blocks ≤ HEARTBEAT_TIMEOUT_BLOCKS − safety_margin_blocks; then derive a phase such as phase = keccak256(chain_id ‖ runner_address) mod effective_cadence_blocks and schedule steady-state on-chain heartbeats in that runner’s phase bucket. Implementations SHOULD still force an emergency refresh before current_block_height − last_heartbeat > HEARTBEAT_TIMEOUT_BLOCKS if normal cadence is missed. The staggering key MUST be runner-specific; implementations MUST NOT use a runner-independent schedule such as “submit when block_height mod N == C”, because that preserves correlated launch, partition-heal, and chain-restart herds and fails to spread them. QUIC reconnect jitter (§11.3) is not a substitute for on-chain heartbeat staggering.
  • Selection cost. Present-first partitioning is O(|eligible|) per job with O(1) bitmap lookups (§7.2 encoding); implementations SHOULD decode PresenceInput once per block and reuse it across all jobs in that block.

6.7 Workload Hints

A CIP-10 workload host claims workloads it finds in the wp: hint index of its host pools (CIP-10 §17.3). A validator pushes each new index entry to subscribed hosts, so an idle slot learns of a registered or updated workload within one block of its finalization instead of on its next scan.
A pool key is the first 20 bytes of keccak256(host_pool), the bytes that follow wp: in every hint key of that pool. A wp: key is wp: ‖ pool key ‖ generation as a big-endian u64, and its value is the workload ID (CIP-10 §17.3). The registry allocates generation from a chain-wide counter, so a registration, a claim, or an update that leaves a workload desired Running writes a key after every existing key of its pool. Hint-only admission. A workload host signs with its slots’ reporter keys (CIP-10 §17.3.5), and a bound slot holds no RunnerRegistration of its own. On a connection negotiated at 0x0101 or above, a validator therefore also admits a party whose address is bound as a slot (runner_slot: row, CIP-10 §17.3.5) to a host whose RunnerRegistration has health != Deregistered, read from the validator’s latest finalized state. Every other §6.2 rule applies unchanged, including the subset gate on the slot’s own key. Such a connection is hint-only. It never enters local presence (§7.4) or push routing (§10.1), from admission on. The validator answers its HeartbeatPing (§6.3) but MUST NOT record it in presence, push jobs to it, or accept BackpressureSignal, CapabilityDelta or result frames from it. Hint-only admission changes no registration and no committed state. A host MAY use any of its slots’ reporter keys, and SHOULD pick one whose connectivity subset (§5.1) contains the validator it dials. Hint-only budget. Every hint-only connection is charged to its slot’s host. A validator keeps at most MAX_HINT_CONNECTIONS_PER_HOST (§13) hint-only connections per host, whichever of the host’s slots authenticated them; admitting one more closes that host’s oldest with Goodbye { RateLimited }. Binding, unbinding or rotating slot keys therefore buys no more connections. A validator also keeps at most MAX_HINT_CONNECTIONS (§13) hint-only connections in total and refuses further ones with Goodbye { RateLimited }. With MAX_HINT_POOLS and MAX_HINT_BACKLOG, these bound the cursor, backlog and heartbeat work one staked host can cause. Subscription. After admission (§6.2), on a connection whose negotiated version is at least 0x0101 (§12.3), the runner MAY send WorkloadHintSubscribe on the control stream. It names at most MAX_HINT_POOLS (§13) distinct pool keys; a longer list or a repeated key is a protocol error. Each subscription replaces the connection’s previous one, and an empty list ends it. A validator MUST NOT accept the frame before admission or on a 0x0100 connection. A runner admitted under its own registration MAY subscribe on its ordinary connection, which keeps ordinary presence and job delivery; a workload host that must not receive jobs authenticates as a bound slot. Derivation. For each subscribed pool key the validator keeps a cursor in the pool’s wp: index. When a subscription names a pool, the cursor starts at that index’s last key in the validator’s latest finalized state, and nothing is sent for keys already there. Whenever its finalized height advances, to h, the validator reads every key of the pool’s index strictly after the cursor in the committed state finalized at h, sends one WorkloadHint per key in key order with block_height = h, and moves the cursor to the last key read. Heights the validator skips lose nothing, because the read covers every key after the cursor. The validator MUST read finalized state only and MUST NOT derive hints during block execution, speculative execution, or replay; hints have no effect on committed state. A validator SHOULD send the hints for height h before it handles height h + 1. Bounds. A validator keeps at most MAX_HINT_BACKLOG (§13) unsent hints per connection. When the backlog is full it MAY drop hints, oldest first; it MUST NOT close the connection or change presence because of a full backlog. A hint is unsigned (§12.6): the admitted connection authenticates its sender, and the hint grants nothing. Runner rules. A hint is never authority. A runner MUST prove the workload record at a finalized checkpoint before it claims, resumes, or binds it, exactly as for a scanned hint (CIP-10 §17.3.3). Because the validator interleaves WorkloadHint frames with HeartbeatPong frames on the control stream, a runner MUST accept a WorkloadHint wherever it reads a control-stream frame. A runner MUST ignore a hint for a pool it has not subscribed, which can arrive while a new subscription takes effect. A runner subscribed on several connections receives each hint once per connection and SHOULD de-duplicate by (pool, generation). Hints can be dropped, a connection can be lost, and a validator may negotiate 0x0100, so a runner MUST keep scanning its pools’ hint indexes at least every WORKLOAD_SCAN_FALLBACK (§13) whether or not hints arrive. A runner that serves many slots from one host SHOULD wake one idle slot per hint rather than all of them.

7. Presence and the Liveness Floor

CIP-11 keeps two separate signals:

7.1 Eligibility Floor (Canonical, On-Chain, Never Overridable)

The floor is the existing on-chain heartbeat-derived health, unchanged in mechanism: a runner with a fresh last_heartbeat (≤ HEARTBEAT_TIMEOUT_BLOCKS) and HealthStatus::Healthy is eligible. This signal is canonical chain state, runner-self-attested, anti-replayed by the ordinary account transaction nonce and signature over the shared release-codec signing digest (§3.3, §10.3), and already read by the dispatcher; it is not protected by a CIP-11-local heartbeat nonce, and CIP-11 MUST NOT depend on a separate Runner Registry last_heartbeat_nonce for replay protection. Because the heartbeat is the runner’s own on-chain attestation, no validator can forge, directly write, or directly clear floor state. An inclusion-controlling majority, or the launch sole validator, can censor the heartbeat transaction; under mandatory proposer rotation, however, no BFT minority can sustain the HEARTBEAT_TIMEOUT_BLOCKS consecutive censoring proposers needed to floor-exclude a healthy runner (§16.2 gives the bound). CIP-11 codifies the heartbeat-derived health check as the floor and makes HEARTBEAT_TIMEOUT_BLOCKS governance-tunable. CIP-11 does not change the CIP-2 on-chain heartbeat transaction or Runner Registry state transition. Because the floor depends on that heartbeat (§16.2), runner clients SHOULD follow the §6.6 staggering rule, choose effective_cadence_blocks no larger than HEARTBEAT_TIMEOUT_BLOCKS − safety_margin_blocks, and force a refresh before the floor would become stale. A reciprocal CIP-2 erratum SHOULD reference this cadence/staggering guidance anywhere CIP-2 describes Runner Registry heartbeat operation.

7.2 PresenceInput (Consensus-Visible, Mode-Aware Source)

PresenceInput is the deterministic per-block input the Job Dispatcher reads to identify currently-present runners, so every node executing the block derives the same present-first ordering. It is never derived from a validator’s local execution-time socket state. Read-point (same-block). PresenceInput(H) is associated with block H, decoded once before executing block H, against the parent-block (H−1) registry index (§8.5), and used for all job selections within block H. (Mode B: it is the committed field of block H; Mode A: it is { runner | presence_proven_until[runner] ≥ H } from parent state.) There is no extra one-block lag beyond the H−1 index basis. The dispatcher’s read-point is identical in all modes; only the source and validation differ:
  • Mode B, single OR multiple validators (NORMATIVE, §8.1–§8.2): carried in the proposed block body and supplied by the proposer, its own live view (single validator) or an off-chain-gossip aggregate (multiple). Best-effort and fail-open (§7.3). Because presence affects which runners the dispatcher selects, it MUST be part of the block’s deterministic pre-execution input and committed in both the execution identity used by propose/verify (execution_hash or its successor) and the block digest. It MUST NOT live only in uncommitted proposer metadata (e.g. the current excluded extra_data path), otherwise propose/verify could cache or replay a different selection than was committed.
  • Mode A, hard-exclude (governance-gated optional, §8.3): fully specified but inactive unless PRESENCE_HARD_EXCLUDE_ENABLED is set (§13). When active, the proposer-supplied field is ignored and PresenceInput is derived from consensus-verified presence_proven_until state maintained by runner-submitted certificates.
Encoding (PresenceInputV1). Bytes are version: u8 = 0x01 ‖ kind: u8 ‖ body. The index basis is the Runner Registry as of the parent block H−1 (§7.2 read-point, §8.5): element i is registry index i.
  • kind = 0x00 (bitmap): body is exactly ⌈|registry(H−1)|/8⌉ bytes; within each byte bit j (LSB-first) is registry index 8·byte + j; every bit at a position ≥ |registry(H−1)| MUST be 0.
  • kind = 0x01 (sparse): body is a u32 count (big-endian) followed by count strictly-ascending u32 registry indices (big-endian).
kind = 0x00 and kind = 0x01 are two encodings of the same abstract present set: a decoder MUST deterministically accept either valid kind and decode it to that set, and a proposer SHOULD choose the smaller. The committed artifact is the proposer’s literal PresenceInputV1 bytes; nodes only decode those bytes to the present set and MUST NOT recompute or re-canonicalize the encoding (so the bitmap-vs-sparse choice is never a consensus mismatch). PresenceInput validity is flag- and mode-scoped:
  1. While CIP11_PRESENT_FIRST_ENABLED is false, PresenceInput is not a block-validity requirement. If the field is absent, malformed, or present only for shadow logging, execution MUST treat the present set as empty for any non-shadow selection behavior.
  2. When CIP11_PRESENT_FIRST_ENABLED is true and PRESENCE_HARD_EXCLUDE_ENABLED is false (active Mode B), each block MUST contain exactly one committed, well-formed PresenceInputV1. A proposer that has no present runners MUST encode a valid empty set. An absent or malformed field is block-invalid in this phase because it is a deterministic execution input that the block must commit.
  3. When Mode A is effective (PRESENCE_HARD_EXCLUDE_ENABLED == true and the §8.4 K_HARD_MIN activation guard is satisfied), the proposer-supplied Mode-B field is ignored for selection. PresenceInput(H) is derived from parent-state presence_proven_until (§8.3); block validity depends on that state derivation. Proposer fields do not determine it. A block MAY omit the proposer field in effective Mode A. If the flag is set but the guard is not satisfied, Mode A is inactive: active present-first selection remains Mode B, the bullet-2 proposer-field requirements still apply, and any block/state transition that hard-excludes a floor-eligible runner due to missing Mode-A proof is invalid.
Malformed means any of: wrong version, unknown kind, wrong bitmap length, a sparse body length not equal to 4 + 4·sparse_count, a set bit beyond |registry|, a non-ascending/duplicate sparse index, or any index ≥ |registry(H−1)|. At ~5,000 runners the bitmap is ~625 bytes. Registry index basis. For block height H, registry(H−1) is the active-runner list stored by the Runner Registry at the end of block H−1. Its canonical storage source is the on-chain value under ACTIVE_RUNNERS_KEY, decoded as the registry’s append-order array of runner addresses; the registry index i is the zero-based position of an address in that array, and |registry(H−1)| is the array length. The active-runner array provides indices without filtering eligibility: health changes, stale-heartbeat marking, pausing, or other liveness-state updates MUST NOT reorder, compact, or renumber it for CIP-11 presence encoding (such runners may still be excluded later by selection eligibility, but their array positions remain part of the PresenceInput index domain). A newly registered runner not already present is appended and receives the next index; existing entries keep their indices. Any future protocol change that removes, compacts, or reorders this array is a consensus-affecting change to the CIP-11 presence index basis and requires a CIP-11 erratum or successor activation before use. Implementations MUST pin this with a test that seeds ACTIVE_RUNNERS_KEY with [A, B, C], marks one unhealthy/stale without rewriting the list, asserts indices 0/1/2 still map to A/B/C, then registers D and asserts D receives index 3, using the same registry storage path as production registration/query code (a separate runner_index_key(i) helper is not the index basis unless production reads/writes it as consensus state).

7.3 Present-First, Fail-Open Selection

Given the eligible candidate set (those passing the floor, §7.1) and PresenceInput:
  1. Partition eligible candidates into the present pool (marked present) and the fallback pool (the rest).
  2. Run the normative §9.2 weighted VRF committee draw (weighted_draw) over the present pool first; if it cannot fill the committee size M, continue the draw over the fallback pool.
  3. In default Mode B, PresenceInput therefore orders selection and routes push delivery; it never removes a floor-eligible runner from eligibility. (Mode A, §8.3, is the documented exception where presence does hard-exclude.)
Guardrails (Mode B):
  • Presence MUST NOT be a hard exclusion of floor-eligible runners. A runner that passes the floor (§7.1) MUST remain drawable from the fallback pool even if it is absent or suppressed from PresenceInput; an implementation MUST NOT use PresenceInput absence (or a backpressure/Goodbye signal) to veto a floor-eligible runner’s selection from the fallback pool. A fabricated or stale “present” bit only wastes a first push attempt, caught by the ack timeout and fallback (§10.6, §11).
  • If PresenceInput is absent or malformed in a phase where §7.2 does not make that block-invalid, the present pool is treated as empty and the committee is drawn entirely from floor-eligible runners. In active Mode B with CIP11_PRESENT_FIRST_ENABLED, absence/malformedness is already block-invalid (§7.2); a valid empty set is the fail-open representation. Either way a missing presence signal degrades to today’s behavior and MUST NEVER fail a job.
Membership-steering bound (multi-validator Mode B). In multi-validator Mode B the proposer supplies PresenceInput (§8.2). By marking only chosen runners present, it could fill a small committee from its own set without excluding anyone. For verification modes whose security relies on multi-runner independence, any job with verification.runners > 1 (MajorityVote, StructuredMatch, Deterministic, SemanticSimilarity), committee membership MUST be drawn by the VRF over the full floor-eligible candidate set. For such jobs presence only routes delivery (§7.4) once membership is fixed. Present-first selection therefore determines membership only where steering cannot undermine verification: single-validator mode (f = 0, trusted proposer); verification.runners == 1 (None / EconomicBond, where the runner’s bond provides integrity); or when Mode A (§8.3) supplies a consensus-verified PresenceInput the proposer cannot unilaterally set. See §16.9 for the analysis and the residual M = 1 bound.

7.4 Local Presence (Per-Validator, Delivery Routing + Evidence Source)

A validator’s local presence set is its off-chain view of which runners it has a healthy authenticated QUIC stream to (from HeartbeatPing, §6.3, and BackpressureSignal, §6.4). It is used to (a) decide whether this validator pushes a given assignment, and (b) form this validator’s contribution to PresenceInput, its own statement under one validator (§8.1), an input to the proposer’s off-chain presence aggregation gossip under multi-validator Mode B (§8.2), and (under Mode A) a dedicated PresenceReceipt it issues for on-chain certificates (§8.3).

7.5 Optional Observability Gossip (Non-Normative)

Implementations may run an advisory observability gossip channel broadcasting local-presence views for dashboards and operator telemetry. This is not the Mode-B presence aggregation gossip of §8.2 and is not consulted for selection, block validity, or any consensus decision.

8. Presence Derivation by Mode, and Security Posture

8.1 Single Validator (Launch and Initial Mainnet)

With one validator, f = 0, and the sole validator observes every runner’s connection first-hand:
  • The proposer sets PresenceInput to its current local-presence set (§7.4). Its signed block is its authoritative statement, so no registry, threshold or aggregation is needed.
  • Selection is present-first and fail-open (§7.3). The present pool is the validator’s live connections, so selection normally picks a connected runner and pushes at once. A runner that disconnects between the presence snapshot and dispatch is caught by ACK_TIMEOUT_BLOCKS and fallback (§16.2).
  • The on-chain heartbeat floor (§7.1) still applies, so a multi-validator network changes only the source of PresenceInput.
The launch delta is a PresenceInput block field, the dispatcher read-point, and node plumbing that passes the §9.2 consensus seeds to execution: parent R_{S-1} for runners==1, and verified threshold seeds by absolute round, including nullification certificates, for runners>1. No commonware protocol change is required. On validator restart the in-memory local-presence set is empty. The next PresenceInput is then empty, and selection fails open to the floor-eligible pool (§7.3) until heartbeats (§6.3) rebuild presence. The proposer MUST mark present only runners registered as of the parent block (§8.5).

8.2 Multiple Validators — Mode B

Mode B works as §8.1 does: the proposer supplies PresenceInput as a committed block field, and execution reads the committed bytes (§7.2). With more than one validator, the proposer aggregates an off-chain gossip in which validators share which runners they hold healthy streams to. This needs no presence certificate, system instruction or consensus vote extension:
  • Every verifier executes against the committed PresenceInput bytes and ignores its own view and the gossip, so all nodes select the same committee.
  • A Byzantine or mistaken proposer can only fabricate or suppress present bits (§7.3). Fabrication wastes a first push attempt that the ack timeout corrects. Suppression leaves the runner in the fallback pool. The damage stays within that proposer’s own slots.
Mode B stays correct when presence is dishonest. On-chain verifiable presence evidence would add cost and bring back the per-runner transaction stream that §2 item 3 aims to reduce. Only Mode A, whose security depends on honest presence, carries that machinery (§8.3, §8.4). The QUIC handshake takes validator identities from the §5.4 ValidatorSetSnapshot, which at launch is the genesis epoch-0 list. Mode B uses it to compute Sub(R) and admit connections (§5.1, §6.2). Mode A also uses it to verify presence certificates (§8.3).

8.3 Mode A Machinery (Opt-in Hard-Exclude)

Mode A is the only posture whose security depends on Byzantine-sound presence, so only it needs consensus-verified presence evidence. It verifies receipts against the §5.4 snapshot and carries presence certificates separately from the threshold finalize signature (§2.1). Its certificate machinery is enforced only when PRESENCE_HARD_EXCLUDE_ENABLED is set (§13). PRESENCE_HARD_EXCLUDE_ENABLED alone is not sufficient to activate hard-exclude behavior: Mode A is effective only when the §8.4 K_HARD_MIN activation guard holds for the active validator snapshot and subset parameters. Below that guard, the certificate machinery MAY be accepted for shadowing/telemetry, but absence of a Mode-A certificate MUST NOT remove a floor-eligible runner from selection.
  1. Validator identities (ValidatorRecord). Mode A verifies receipts against the §5.4 ValidatorSetSnapshot, which holds one execution-readable record per validator:
The validator’s position is its position in the snapshot’s canonical participants order (§5.4); CIP-11 does not define, sign, hash, or consume a separate index field. peer_pubkey is the validator’s Ed25519 commonware peer identity. The validator signs CIP-11 control-plane frames and PresenceReceipts with it, so the state-transition function can verify that a receipt came from a real validator. The snapshot does not store the BLS12-381 threshold key (§2.1). The §6.2 custody rule governs this key in every mode. validator_set_hash excludes the mutable stake, so the hash and connection_id stay stable across stake changes. An identity change is a reconfiguration, which the §5.3 overlap window handles.
  1. Presence receipt and certificate. A PresenceReceipt is a dedicated, chain-verifiable signature. The QUIC HeartbeatPong cannot serve here, because it signs over connection_id, which execution cannot reconstruct. The receipt signs a domain with no channel binding that carries the epoch inputs, so execution can verify it directly:
nonce_echo is signed as replay entropy. Execution has no per-connection state, so it does not check nonce_echo against a challenge. The receipt’s chain_id is the executing network’s chain id. A receipt is verified on-chain without a connection, so the §12.6 connection-scoped origins rule does not apply. A receipt whose chain_id differs from the executing network’s is invalid.
A validator issues a PresenceReceipt (alongside its HeartbeatPong) when a runner indicates it will seek a Mode-A certificate; the runner collects them. Verification: each receipt.runner_pubkey and receipt.validator_pubkey is a scheme-tagged wire PubKey (§12.6); the verifier first validates its scheme_id/length and strips the tag to recover the raw key material. The runner Address MUST resolve to a RunnerRegistration. Every receipt MUST carry the same runner_pubkey (scheme 0x01), and that secp256k1 public key’s derived EVM address MUST equal both the certificate’s runner field and RunnerRegistration.address; runner_signed MUST recover that same runner Address over the SubmitPresenceCertificate payload (the ordinary chain transaction signature). For each receipt, the (subset_epoch, validator_set_hash) MUST select one active/overlap snapshot (§5.3 epoch-paired rule) and the tag-stripped validator_pubkey (scheme 0x02) MUST equal the raw peer_pubkey of a validator in Sub_epoch(runner.auth_pubkey) in that same snapshot (where epoch is E or E+1 as selected by the offered (subset_epoch, validator_set_hash)); validator_signed (Ed25519) MUST verify under that peer_pubkey. A SubmitPresenceCertificate is valid only if every counted receipt satisfies all of: accepting_new MUST be true (§6.4); the receipt MUST be fresh (receipt.block_height ≤ height ≤ current_block_height and height.saturating_sub(receipt.block_height) ≤ RECEIPT_FRESHNESS_BLOCKS); the certificate MUST contain at least t_hard distinct valid receipts after raw-peer_pubkey deduplication (step 4 below); and the certificate MUST be strictly newer than the runner’s current anchor (max(counted receipt.block_height) > presence_anchor[runner]). On acceptance the chain sets presence_anchor[runner] = max(counted receipt.block_height) and presence_proven_until[runner] = presence_anchor[runner] + PRESENCE_PROOF_TTL_BLOCKS. Anti-replay rests on two facts: the TTL runs from the receipt observation height, and the anchor is strictly monotonic. Replaying older receipts therefore cannot extend presence beyond the last genuine observation plus PRESENCE_PROOF_TTL_BLOCKS. Each receipt is bound to (chain_id, runner, validator, subset_epoch, validator_set_hash, block_height, nonce_echo, accepting_new) via the §12.6 domain. An offline runner therefore cannot keep itself present: once its newest genuine receipt ages past the TTL, no replayable receipt can re-certify it.
A non-normative alternative is a validator presence sidecar, in which validators sign per-block runner bitmaps that the proposer includes. It is more invasive and needs proposer-inclusion rules.
  1. State-derived read point. At the start of block H, before executing transactions, execution derives from parent state:
Certificates included in block H update presence_proven_until for H+1 onward; using parent state avoids any intra-block ordering dependence between a certificate transaction and a job-submit transaction.
  1. Threshold (Mode A). A certificate MUST carry at least t_hard distinct valid receipts, a governance-selected honest-majority-of-k target, paired with a k large enough for the intended censorship-resistance (§8.4). Distinctness is keyed by the raw, tag-stripped validator peer_pubkey bytes (after scheme validation). The verifier ignores (validator_pubkey, subset_epoch), validator_set_hash, signature bytes, receipt order, and any wire PubKey tag when counting distinct validators. During an E → E+1 overlap, a validator that appears in both Sub_E(runner) and Sub_{E+1}(runner) may submit otherwise-valid receipts under both epoch preimages, but those receipts contribute at most one validator toward t_hard; if multiple valid receipts share the same raw peer_pubkey, the verifier retains the one with the greatest block_height for anchor computation and ignores the rest for threshold counting.
Evaluation order and metering (Mode A). The validity predicates above define what makes a certificate/receipt valid; the following evaluation order is also normative for DoS resistance. Execution MUST perform all signature-free certificate/receipt rejection checks before Ed25519 verification whenever they can be evaluated without the validator signature:
  1. Before iterating receipts, execution charges PRESENCE_CERT_BASE_CYCLES and decodes the SubmitPresenceCertificate through the ordinary transaction path (the runner transaction signature/nonce is the normal account anti-replay).
  2. For every submitted receipt entry, execution charges PRESENCE_RECEIPT_PRECHECK_CYCLES before any receipt-specific signature verification. Malformed encodings, wrong scheme tags/lengths, runner-key mismatch, accepting_new != true, stale/future heights (the freshness rule above), inactive/non-overlap (subset_epoch, validator_set_hash), unknown validator keys, and validators outside Sub_epoch(runner) are rejected using only decoded fields and snapshot state. Duplicate raw validator keys are bucketed here, but a higher-block_height candidate MUST NOT discard lower-height candidates until the higher one’s signature has verified.
  3. Only prechecked candidates reach Ed25519 verification. Immediately before each attempt, execution MUST charge PRESENCE_RECEIPT_ED25519_VERIFY_CYCLES whether the signature succeeds or fails, and MUST NOT attempt a verification without enough remaining cycles to pay for it.
  4. Distinctness remains keyed by raw tag-stripped peer_pubkey. For each raw validator key, execution considers prechecked candidates in descending block_height order and verifies until it finds the greatest valid signed receipt for that validator, then ignores the rest for that validator. A forged higher-height receipt therefore cannot suppress a lower-height valid one; it only costs the submitter the charged verification attempt.
  5. Threshold counting, strictly-newer-anchor checking, and the presence_anchor / presence_proven_until updates use only the retained, signature-valid per-validator receipts.
Indexing follows §8.5.

8.4 Security Posture and the k ↔ Security ↔ Fan-out Trade-off

Presence evidence for a runner can only come from validators connected to it, i.e. its subset Sub(R), size k. Under the BFT bound (< 1/3 Byzantine), a small subset can be adversary-majority (e.g. for k = 8 under a hypergeometric draw from a 33%-Byzantine population, ~26% chance ≥ 4 of 8 are Byzantine, the i.i.d.-binomial upper bound; the exact hypergeometric is slightly lower at small n, which only strengthens the rejection argument), so a small-k presence signal cannot be a Byzantine-secure hard exclusion. This yields three postures:
  • (B) Present-first, fail-open, NORMATIVE (§7.3). Presence orders and routes; the heartbeat floor governs eligibility. It is secure at k ≤ 8 with bounded fan-out. Fabrication costs a wasted first attempt. Suppression leaves the runner in the fallback pool, though it can deny the runner work in that proposer’s slot (§16.9).
  • (A) Hard-exclude, DOCUMENTED high-security upgrade. A runner without presence evidence is not selectable. To be censorship-resistant it requires honest-majority subsets, i.e. large k (tens to ~100+ depending on target failure probability), raising per-validator connections to ~|R|·k/n. Mode A is additionally guarded by K_HARD_MIN (§13): let effective_k = min(|V|, clamp(ceil(log2(|V|))+1, MIN_SUBSET, MAX_SUBSET)); hard-exclude behavior is effective only when effective_k ≥ K_HARD_MIN (default 20) and t_hard ≥ floor(effective_k/2)+1, so the default MAX_SUBSET = 8 cannot accidentally instantiate the rejected small-k hard-exclude posture (C). A block that applies hard-exclude while the guard is false is invalid. The normative certificate evidence path generates gas-bearing transactions; at |R| ≈ 5,000 the block-space cost is approximately |R| · (t_hard · 188 B + envelope) / PRESENCE_PROOF_TTL_BLOCKS(=60) per block, roughly 172 KB/block at k=20/t_hard=11, and 800 KB/block at k=100/t_hard=51. Mode A is gated by PRESENCE_HARD_EXCLUDE_ENABLED (default false, §13); only a governance vote may enable it, and governance MUST satisfy the K_HARD_MIN guard, size k for the target censorship-resistance, and budget for the on-chain byte volume. While the flag is false (always, at launch), presence cannot remove a floor-eligible runner and the §7.3 fallback-pool guarantee holds unconditionally.
  • (C) Hard-exclude at small k, REJECTED. Hard exclusion with k ≤ 8 exposes ~25% of runners to suppression/censorship with no adequate in-protocol mitigation: subset rotation (§5.3) only reshuffles across epochs and cannot fix an adversary-heavy subset within an epoch. Not specified.
B is normative because job delivery matters more than the risk that a multi-validator proposer griefs a single runner. Governance can choose A for a deployment that needs stronger security.

8.5 Indexing Across Registry Mutations

Presence is indexed by Runner Registry order as of the parent block H−1 (the PresenceInput(H) index basis, §7.2). A runner registered in block H is not in the H−1 index, so it cannot appear in PresenceInput(H); it first appears in PresenceInput(H+1) (indexed against the registry as of H) and is therefore present-eligible for jobs selected in block H+1. Until then it is in the fallback pool (§7.3). A runner deregistered/unhealthy in H is still excluded by the floor (§7.1) at selection regardless of a historical presence bit.

9. Updated Selection Algorithm

CIP-11 changes the existing dispatcher in three targeted ways:
  • The candidate filter chain: the heartbeat-derived eligibility floor is codified/parameterized (existing filter made normative, §9.1).
  • The committee draw is made present-first using PresenceInput (§7.3, applied in §9.2), subject to the §7.3 membership-steering bound (multi-validator runners > 1 jobs draw membership over the full eligible set).
  • The base draw weight remains the CIP-2 v3 §2 VRF weight effective_stake · sqrt(reputation); CIP-11 adds only the iteration-0 MRU multiplier on top of that base (§9.3).

9.1 Candidate Filter Chain (Eligibility Floor)

The chain below is the existing dispatcher filter chain, reproduced for context. CIP-11 codifies only Filter 1, the liveness floor. Each other filter’s owner is cited inline:
Filter 1 makes the heartbeat-derived health gate the eligibility floor (§7.1), with a tunable HEARTBEAT_TIMEOUT_BLOCKS. The other rows only locate the insertion point, and their owning CIPs define them. Presence applies after this chain as draw ordering (§7.3) and removes no candidates unless Mode A is effective (§8.4).

9.2 Selection Algorithm

The stake-weighted VRF selection is preserved in structure, but CIP-11 amends CIP-2 §5/§10 for seed timing, seed identity, and domain separation, and defines the draw normatively (weighted_draw and partition below). Let S = submitted_at be the block that includes JobSubmit, M = job_spec.verification.runners, T = S the job’s selection-state snapshot block, and H the assignment block (the block in which the committee is actually written; H = S for M == 1; for M > 1, H is the pending-selection pass block once the seed and finality conditions below hold). For every first selection, the CIP-2 filter chain, candidate reputation filter, candidate ordering, candidates-snapshot root, effective_stake(r, T), selection_reputation_x1e9(r, T), ReputationConfig_at(T), and base weights are all evaluated against the block-T state snapshot. CIP-11 changes the randomness beacon/domain/identity and, for M > 1, the assignment timing; it does not move the CIP-2 candidate/weight snapshot forward past T = S. For M == 1, selection remains immediate in block S (no added latency), using the parent beacon available before executing S:
For M > 1, selection uses commit-then-reveal randomness over an absolute future consensus round (per commonware’s threshold-VRF guidance: it is not safe to use a round’s randomness to affect execution in that same round). Let:
  • S = submitted_at, the block height that includes JobSubmit;
  • r_submit = Round(epoch, view), the absolute consensus round in which block S was proposed;
  • T = S, the CIP-2 selection-state snapshot height;
  • K = SELECTION_SEED_DELAY_VIEWS;
  • r_seed = advance_round(r_submit, K).
advance_round(round, k) is consensus-owned round arithmetic over the active epoch schedule: it advances by k views in total Round order, carrying across an epoch boundary per the consensus epoch-transition rules. Execution MUST NOT implement raw view + k across epoch boundaries itself. If the referenced future round cannot yet be mapped because the epoch schedule is not known, the pending selection remains pending until it can be mapped; implementations MUST NOT choose a substitute round. JobSubmit in block S validates the job and fixes job_id, submitted_at, T = S, r_submit, r_seed, and the block-S candidates_snapshot_root. The transaction MUST NOT write runner assignments in block S. A later deterministic pending-selection pass assigns the committee only when all of the following hold:
  1. block S is finalized and applied to canonical local state;
  2. the verified commonware threshold seed for exactly r_seed is available to the proposer and committed in the assignment block (consumed-seed commitment below); verifiers and replayers evaluate this condition solely against the committed ConsumedSeedsV1 entry;
  3. the candidate snapshot derived from canonical block-S state matches the committed candidates_snapshot_root.
If any condition is false, the pending selection MUST remain pending. Implementations MUST NOT replace r_seed with the seed from the round that finalized height S, with the parent beacon, with a block hash, with an execution hash, or with any later “next available” seed. This is the commit-then-reveal rule: the job binds before the seed is known, and the seed is identified by an absolute future Round(epoch, view) fixed from the submission block’s own proposal round. The mode byte is consensus-critical: 0x00 = immediate single-runner selection (M == 1), selected in block S using the parent beacon; 0x01 = delayed multi-runner selection (M > 1), selected after the future seed r_seed is readable and all pending-selection conditions above hold. The ASCII domain cowboy-runner-select-v3: replaces CIP-2’s cowboy-runner-select-v2: regardless of the presence-selection settings (§13); implementations MUST NOT reuse the v2 domain with the v3 preimage. The v3 selection preimage is:
For M == 1, R is the parent execution-readable consensus beacon (R_{S-1}). For M > 1, R is the commonware threshold seed whose Seed.round equals r_seed. Implementations MUST NOT use a block hash, execution hash, proposer timestamp, or height-only proxy as the randomness source. canonical_seed_bytes. canonical_seed_bytes(R) is exactly the 32-byte beacon_hash_v1(R):
epoch_be8 and view_be8 are the unsigned 64-bit big-endian values from R.round = Round(epoch, view). scheme_id_u8 = 0x01 denotes commonware BLS12-381 threshold VRF MinSig (the active Cowboy consensus scheme); signature_bytes MUST be the 48 compressed G1 bytes emitted by commonware’s G1::write, and signature_len_be2 = 0x0030. scheme_id_u8 = 0x02 is reserved for MinPk (96 compressed G2 bytes, signature_len_be2 = 0x0060) if a future consensus change activates it. Implementations MUST verify the seed signature against the active consensus threshold public key and that R.round equals the expected absolute seed round before computing beacon_hash_v1, and MUST NOT use raw commonware-codec bytes, CBOR bytes, a block hash, a height-only proxy, or an implementation-selected alternate hash in the selection preimage. candidates_snapshot_root. candidates_snapshot_root is the root of a binary Merkle tree over the block-T selection snapshot (T = submitted_at = S for first selection), in the deterministic candidate order after the CIP-2 filter chain, candidate reputation filter, and address ordering at block T. Each leaf commits the candidate and the weight inputs used by this selection:
index_be4 is the zero-based index in the ordered snapshot; effective_stake, selection_reputation_x1e9, and base_weight are evaluated at T = S using ReputationConfig_at(T) and the CIP-2 v3 weight formula. Including base_weight commits the exact block-S selection inputs while avoiding storage of the expanded candidate list. Tree construction: the empty-snapshot root is keccak256("cowboy-candidates-empty-v1"); a one-leaf tree’s root is that leaf; an internal node is keccak256("cowboy-candidates-inner-v1" ‖ left_32 ‖ right_32); for any level with an odd number of nodes, duplicate the final node before hashing the next level. The tree is always binary; no other arity, padding, or promotion rule is valid. At the pending-selection pass the dispatcher MUST re-derive the ordered block-S snapshot from canonical historical state, recompute the root, and compare it byte-for-byte to the committed candidates_snapshot_root; if they differ, the block is invalid. A non-consensus local cache of expanded candidates/weights MAY be used as an optimization only; replay MUST be correct without it. This definition is also a CIP-2 erratum that defines the candidates_snapshot Merkle root. Pending-selection storage. For M > 1, block S records:
PendingSelectionV1 is encoded with the §12.6 “CIP-11 deterministic CBOR profile”; canonical map keys are unsigned integers in declaration order starting at 0 for version. Two storage keys are written:
pending_by_job_key is for direct lookup. pending_due_round_index_key is an iterable lexicographic consensus index, not a hash; implementations whose storage engine lacks ordered byte-prefix/range scans MUST maintain a logically equivalent per-round ordered list, with the lexicographic index as the consensus semantics. Block S MUST write both keys atomically with the rest of JobSubmit execution for M > 1; a second live pending record for the same job_id is invalid. At the start of block H, before ordinary transaction execution, the dispatcher scans the pending due-round index and collects every pending record whose submission block S is finalized and whose exact Round(seed_epoch, seed_view) seed is committed in block H (consumed-seed commitment below), then MUST process the collected records in ascending (submitted_at, job_id) order, submitted_at numeric ascending, job_id lexicographic byte order. Storage iteration order MUST NOT change this processing order. If a record’s seed is not committed in H or S is not finalized, it remains pending under the same keys (MUST NOT re-key to a different seed round or choose a replacement seed). A proposer that has not observed the seed for a due record simply leaves it pending; verifiers cannot and MUST NOT treat an unprocessed due record as a validity fault (whether the proposer “had” the certificate is unobservable). Withholding therefore delays one slot at a time and is bounded by proposer rotation, exactly like transaction-inclusion censorship. On successful assignment the same state transition MUST: (1) verify a live pending record exists under pending_by_job_key, record deletion in step (4) is the consumption marker; there is no separate consumed flag; (2) re-derive and verify candidates_snapshot_root; (3) write the runner assignment and assignment metadata and set the job’s assignment height to the current block H; (4) delete both pending_by_job_key and pending_due_round_index_key atomically. A block that assigns an M > 1 job without a live pending record (an already-deleted record is the consumed state), with a seed other than the record’s committed (seed_epoch, seed_view), or whose snapshot root does not verify is invalid. Consumed-seed commitment. The threshold seed consumed by a pending selection determines the selection in block H, and when r_seed was nullified its certificate is not durable chain data (live nodes prune nullifications; only finalizations are archived). Seed availability MUST NOT be a local-node predicate. Block H MUST carry a consensus-committed block field ConsumedSeedsV1, covered by the execution identity (execution_hash) and the block digest exactly like PresenceInput (§7.2): the list of (seed_epoch: u64, seed_view: u64, seed_signature: [u8; 48]) entries for every distinct seed round consumed by a pending record processed in H, deduplicated by round, sorted ascending by (seed_epoch, seed_view), and encoded with the §12.6 deterministic CBOR profile (48 signature bytes per the active MinSig scheme; a future MinPk activation changes the length together with the §9.2 scheme_id). Block validity: every processed record’s (seed_epoch, seed_view) MUST have exactly one entry; every entry MUST verify as the threshold seed signature for its round under the threshold public key of the epoch named by seed_epoch; an entry that no processed record consumes is invalid. Verification and replay MUST derive each §9.2 selection seed from exactly these committed bytes, never from a locally observed certificate. Thus M > 1 assignment is verifiable and replayable from chain data alone, including for nullified seed rounds whose certificates no live node retains. Because the threshold seed is unique per round, committing it grants the proposer no grinding power: the proposer chooses only when a due record is processed (bounded by rotation, above), never which seed it gets. Execution-readable seed exposure (consensus integration, MUST). Seed exposure MUST include every verified consensus certificate type that carries a valid threshold seed for an absolute round: notarization, finalization, and nullification. commonware signs the seed namespace over only Round(epoch, view) for all three subjects, so a nullified r_seed still has exactly one valid seed for that round and MUST be usable for pending runner selection once verified/readable. Exposing only notarization/finalization seeds is non-conforming. A nullified r_seed would leave otherwise-valid jobs pending forever. This exposure feeds the proposer at assignment time; block verification and historical replay rely on the committed ConsumedSeedsV1 bytes above, never on local certificate availability. Selection-seed delay invariant. SELECTION_SEED_DELAY_VIEWS counts consensus views. It does not count blocks. Implementations MUST NOT derive an assignment height by adding this view count to S; any separate liveness throttle MUST be a distinct block-count parameter and is not part of the seed identity. K = 3 is the default launch value; activation requires the consensus integration to demonstrate that, under the deployed Simplex timers and execution pipeline, block S is finalized before the seed for advance_round(r_submit, K) can be revealed to a proposer/coalition able to condition publication on it. If that invariant is not met, governance MUST raise K or use a future-epoch seed before enabling M > 1 CIP-11 selection. Whitepaper erratum. The technical whitepaper describes R_n = VRF(QC_{n-1}) (parent-QC randomness). CIP-11 requires the execution-readable seed to follow the actual commonware threshold-VRF model: a verified Seed { round: Round(epoch, view), signature } for a named absolute round. CIP-11 does not treat height S and Seed.round as interchangeable. This is a CIP-2 selection erratum. For M == 1 genesis bootstrapping, the chain configuration MUST define a consensus genesis beacon; any block whose parent beacon is unavailable (only blocks whose parent predates the first certified round) uses that configured genesis beacon, so the M == 1 path is total. There is no M == 1 pending state. Activating CIP-11 selection (CIP11_PRESENT_FIRST_ENABLED, §13) on a chain whose configuration lacks a genesis beacon is invalid. A reorg removes or replays the committed PendingSelectionV1 and candidates_snapshot_root exactly with block S; the pending pass re-derives the same block-S snapshot from canonical state, verifies the root, and selects with the committed seed for the named absolute r_seed. Reorg replay MUST NOT depend on any non-consensus local cache. The commit-then-reveal schedule applies to all M > 1 jobs in every topology, including the single-validator launch. §16.9 covers the grinding it closes and the bounded residual. M == 1 keeps immediate R_{S-1} selection, which retains MEV and fairness risks without weakening multi-runner integrity. For M > 1 jobs, the assignment block H is the pending-selection pass block satisfying the conditions above; push delivery, ack deadlines, and result deadlines are computed from H, while submitted_at = S remains part of the seed preimage. Timeout re-selection (§11.2 / CIP-2 §6) derives from this original v3 seed exactly as CIP-2 derives from its original seed. The remaining CIP-11 changes are the present-first pool ordering (§7.3) and the iteration-0 MRU weight (§9.3). The CIP-2 filter chain and v3 base weight formula are otherwise preserved, with weights evaluated at T = S (§9.3). The assignment block H sets when the assignment is written and which PresenceInput(H) applies. It does not change the candidate and weight snapshot. Normative present-first draw. To keep two implementations bit-for-bit identical, the draw is defined as a single global iteration over a per-iteration active pool (present runners until exhausted, then fallback):
Normative partition and weighted_draw. partition(eligible, PresenceInput(H)) is stable: it iterates eligible in its existing deterministic order and appends each runner to present iff that runner’s registry index/address is marked present by PresenceInput(H), else to fallback. A runner appears in exactly one output list. partition MUST NOT sort either output list by presence, stake, weight, connection state, or registry index. weighted_draw(pool, weights, seed, i) is consensus-critical and defined as:
  1. pool.len() == weights.len() MUST hold; each weight is paired with the runner at the same index.
  2. total_weight = sum(weights) as u128.
  3. If pool is empty or total_weight == 0, the draw returns None; the loop stops and any shortfall falls to the CIP-2 under-fill / timeout re-selection path (§11.2).
  4. h = keccak256(seed ‖ i_le8), where i_le8 is the unsigned 64-bit little-endian global draw iteration.
  5. ticket = u128(u64::from_le_bytes(h[0..8])) % total_weight.
  6. Walk weights in current pool order; select the first index j with ticket < weights[j], subtracting each non-selected weight from ticket as you pass it.
  7. Return the index j (or None per step 3). The caller (the draw loop above) appends pool[j] to selected and removes the runner together with its paired weight via swap_remove(j); the residual pool order after the first draw is therefore not address-sorted and MUST be replayed exactly.
The selection seed is fixed for the whole committee. Implementations MUST NOT chain seed = h between iterations, MUST NOT use prefix-swap Fisher-Yates, and MUST NOT re-sort the residual pool after swap_remove. This pins the live dispatcher draw semantics and is a CIP-2 §5 erratum. Implementations MUST include a pin test with ≥3 candidates whose addresses are not initially sorted and whose stake/reputation weights are distinct, verifying that weights stay paired with their runners after address sorting, present/fallback partitioning, and swap_remove (computing weights before sorting and indexing them through sorted candidate indices is non-conforming). Normative points: (a) for any branch where present-first determines membership, the active pool is present while any present runner remains, and only then fallback. Concatenation is not sufficient, since a single weighted draw over present ++ fallback would let a fallback runner win at i = 0; (b) the iteration counter i is global and continuous when selection moves from the present pool to the fallback pool (it does not reset); (c) the MRU multiplier applies once, only at global i == 0, to whichever pool is active then; (d) [Mode B] if PresenceInput is empty/malformed, present is empty so every present-first iteration draws from fallback == eligible, making the draw identical to today’s except for the seed/MRU changes; [Mode A] empty/malformed/insufficient proven-present makes both present and fallback empty, so the loop under-fills and the job falls to §11.2 re-selection, never to a non-present runner (hard-exclude, §8.4); (e) weights are the CIP-2 v3 §2 weights, with effective_stake as the stake term, computed over the active pool and kept paired with their runner (never compute weights over one ordering and index them under another); the selection_reputation_x1e9(r, T) input MUST be the same block-T reputation snapshot (T = submitted_at = S) used by the candidate reputation filter for that selection. Implementations MUST NOT filter candidates at S but weight them from S+1 (or any later block), and MUST NOT use one reputation/config snapshot for filtering and another for weighting. If |eligible| < M, the loop breaks early; the shortfall is handled by the existing CIP-2 under-fill / timeout re-selection path (§11.2). A job is never failed for lack of present runners.

9.3 MRU Weight Multiplier

CIP-11 does not define a new base weighting function. Base weight is the CIP-2 v3 §2 VRF weight, evaluated at the job’s selection-state snapshot block T = submitted_at = S, with CIP-13 v2 effective_stake supplying the stake term:
Where:
  • effective_stake(r, T) = r.registration.stake_at(T) + r.delegation_totals.total_active_at(T) (CIP-13 v2 §3.2). Until delegation is live, delegation_totals.total_active = 0, so effective_stake(r, T) = r.registration.stake_at(T).
  • selection_reputation_x1e9(r, T) is the same reputation value used by the CIP-2 v3 candidate reputation filter for this selection at block T: the lazy-decayed EMA reputation read from RunnerRegistration.reputation under the active ReputationConfig_at(T) (CIP-2 v3 §3). Implementations MUST NOT use one reputation snapshot for filtering and another for weighting.
  • cip2_v3_weight is the CIP-2 v3 §2 formula effective_stake · max(sqrt(reputation / REPUTATION_NORMALIZER), w_min_floor).
The square-root factor is consensus-critical and MUST be computed with deterministic integer or fixed-point arithmetic. Floating-point or platform math does not satisfy this requirement. The canonical current implementation encodes the factor at Q1e6:
The MRU multiplier is then applied once, only at global draw iteration i == 0 (§9.2 weighted_draw), on top of the complete base weight:
Iterations i ≥ 1 use base_weight with no MRU multiplier. If the MRU runner is not in the active pool being drawn at global i == 0, no bias applies. Defaults MRU_TTL_BLOCKS = 1,280 (~21 min), MRU_WEIGHT_MULTIPLIER = 4; governance-adjustable. lookup_mru(submitter, job_kind, H) reads the MRU state at the assignment block read point H (= current_block_height at the pending-selection / assignment pass) and returns Some((addr, set_at_block)) only if the record exists and H − set_at_block ≤ MRU_TTL_BLOCKS, with saturating subtraction for genesis-range heights. The MRU record is keyed (submitter, job_kind) and stores (addr, set_at_block); the multiplier applies once, only at global i == 0, and only if addr is present in the active pool at that exact iteration. If the record is absent, expired, or not in the active pool at i == 0, no MRU multiplier applies to any iteration.
Implementation note. Current select_runner_committee_with_seed already uses the CIP-2 v3 helper v3_runner_weight(stake, reputation_x1e9, reputation_normalizer, w_min_floor_x1e6) and deterministic u128::isqrt. CIP-11 implementations pass effective_stake(r, T) in place of raw registration.stake once CIP-13 delegation is live, preserve the same reputation snapshot used by Filter 2, and apply the iteration-0 MRU multiplier.

9.4 New Dispatcher State: mru_key

MRU reads and writes are unconditional from genesis. Direct M == 1 draws, M > 1 pending-selection draws and timeout re-draws consult the same record. The §13 flags do not gate them.
job_kind is a CIP-11-owned stable consensus-byte table, authoritative independent of any Rust enum discriminant or source order (the node and runner JobType enums are declared in different orders, so a source-order discriminant would be ambiguous): Llm = 0x00, Http = 0x01, Mcp = 0x02, Custom = 0x03, PublishChainRoot = 0x04, Agent = 0x05, Container = 0x06, RouteInvocation = 0x07, PrivateHttp = 0x08. New variants MUST be appended with the next free byte, and an implementation MUST pin this table with a test against both the node and runner JobType enums so reordering either cannot silently change mru_key.
CIP-2 enumerates only Llm/Http/Mcp/Custom. The table above follows the deployed node enum and is authoritative for job_kind in CIP-11. A separate CIP-2 cleanup SHOULD reconcile the canonical JobType set and its governance so the two specs do not drift; this is not a CIP-11 implementation prerequisite.
Write path (Result Verifier). On a verified result for (submitter, job_kind), write mru_key := { r, current_block_height }, where r is the first consensus-matching runner in the original selected committee order (the dispatcher MUST store committee order with the job record). The consensus-matching set is the assigned runners whose accepted reveal contributed to the verified result (the single runner for VerificationMode::None, the winning cluster otherwise), minus the ineligible set. The ineligible set, runners_to_slash ∪ runners_unrewarded, covers every submitter whose bundle did not verify, whether or not it was provably dishonest. An MRU record is a reward, so the test is whether the submission did the work. Excluding only runners_to_slash would pay routing preference to free-riders. Arrival, reveal, delivery and map-iteration order MUST NOT affect the choice. Read path (Dispatcher). Iteration-0 weighting reads mru_key. A value of None or a record older than MRU_TTL_BLOCKS applies no bias. A record is live through set_at_block + 1,280 inclusive and ignored starting at the next block. Storage uses actor 0x02, key mru: plus submitter[20] and job_kind[1], with a JSON-encoded MruRecord value. Each verified write also records job_mru: plus job_id[32], containing submitter[20] and job_kind[1] (21 bytes). Lifecycle. The terminal-job reaper reads that back-pointer and deletes the MRU row only when reap_height.saturating_sub(set_at_block) > MRU_TTL_BLOCKS, then deletes the back-pointer with the job’s other dispatcher keys. A refreshed live record survives an older job’s reap. The last writer’s reap follows the record-retention period in CIP-2, beyond the MRU lifetime. Cleanup uses the job’s admission-owned reap reservation; admission refuses jobs when no slot fits. CIP-2’s pause and damaged-state qualifications apply to cleanup, and expired rows never affect selection.

9.5 MRU Scope (Future Refinement)

Default (submitter, job_kind) is coarse; (submitter, model_id) (LLM) and (submitter, primary_volume_id) (storage) would be better. A future revision MAY add an extensible mru_scope on JobSpec; v1 ships the coarse default (§17).

10. Push Job Delivery

10.1 Dispatch

A validator pushes only after the assignment block is finalized and applied to canonical local state. Under a single validator, finalization is immediate and application takes about one block, so delivery takes block inclusion, application and one RTT, about 1–2 s at 1 s blocks. For each such assignment to runner R, every validator with a live stream to R in local presence opens a job stream and sends:
assignment_hash = keccak256(JobAssignment §12.6 preimage), and validator_signed is the validator’s Ed25519 signature (over that digest) under its peer_pubkey. Up to k validators may send the same job_id; the runner MUST deduplicate by job_id. For a given job_id the runner MUST accept at most one valid JobAssignment: it sends JobAck { Accepted } only on the accepted stream, MUST send JobAck { Duplicate } for every other valid assignment for that job_id, and MUST NOT execute or send result frames on any duplicate stream. All validators pushing the same assignment MUST send byte-identical assignment payload fields for job_id, job_spec, job_spec_hash, assignment_height, assignment_hash, deadline_block, and runner_pubkey; only validator_pubkey/validator_signed and the QUIC stream identity may differ. A runner MUST reject as Reject(UnverifiableAssignment) any otherwise-valid push for the same job_id whose non-validator assignment fields differ from the assignment it accepted, and MUST NOT treat it as a harmless duplicate. runner_pubkey and validator_pubkey are scheme-tagged wire PubKeys (§12.6); the runner validates each scheme_id/length and strips the tag before comparison. Before acking/executing the runner MUST verify job_spec_hash, recompute and check assignment_hash, that the tag-stripped validator_pubkey (scheme 0x02) equals the raw peer_pubkey of a validator in the active snapshot and that validator_signed verifies under that peer_pubkey, and that the tag-stripped runner_pubkey (scheme 0x01) is its own; and MUST NOT begin expensive execution unless assignment_height is finalized+applied in its own view (else JobAck { Reject(UnverifiableAssignment) }). A runner that finds itself no longer assigned at assignment_height (e.g. deregistered, or re-selected away between selection and push) likewise rejects with Reject(UnverifiableAssignment). Re-push on a new connection. A validator records the connection each push reached an outcome on, and does not push the same (runner, job_id) again on that connection. When a runner connects on a new connection, a reconnect after link loss, or a restarted runner process that lost its in-memory state, the validator MUST push again every assignment still live for that runner (in its committed jobs index, deadline_block not passed). The runner deduplicates by job_id as above: an assignment it still holds is acked Duplicate (its retained result transactions settle via §10.3), and one it lost is acked Accepted and executed. Because push is the only delivery path, this is how a restarted runner recovers its assigned work. The chain determines deadline_block. For an initial assignment it MUST equal the timeout-index block consensus/execution will use for the job (job_spec.submitted_at + job_spec.timeout_blocks under the current CIP-2 dispatcher rule); for a timeout re-selection/retry it MUST equal the newly scheduled timeout-index block (current assignment block + job_spec.timeout_blocks). §11.2 consumes this same value; validators MUST NOT shorten or extend it in the push frame. Changing this formula (e.g. to min(submitted_at + timeout_blocks, H + JOB_TIMEOUT_BLOCKS)) would be a consensus change.

10.2 Runner Acknowledgment

The runner_pubkey and validator_pubkey in the §12.6 JobAck preimage are the authenticated identities of the QUIC connection the ack is sent on (§6.2). They do not use separate frame fields; a validator MUST reject a JobAck whose assignment_hash does not match a JobAssignment it sent for job_id on that connection. Duplicate is the expected, non-failure ack when another validator’s dispatch arrived first. Reject means the runner is alive but cannot serve the job, which falls to other validators or timeout re-selection.

10.3 Result Commit and Reveal

CIP-11 keeps the existing CIP-2 commit-reveal settlement: for multi-runner jobs each runner first submits a hash commitment to its result, then, once the reveal window opens, the plaintext result plus salt, and the Result Verifier accepts a reveal only if it matches a prior commitment (this prevents runners copying each other). CIP-11 carries that material over QUIC instead of REST, and the settlement transaction and mempool path stay the same. A runner MUST accept a given job_id from at most one validator, MUST ack that stream Accepted, MUST ack all other valid pushes for that job_id as Duplicate (§10.2), and MUST send JobResultCommit / JobResult frames only on that Accepted stream. The one exception is a native session report: a JobResult whose JobResultSubmit reports on a session’s parent job, whose Accepted stream ends when the session opens. The runner sends it on the control stream of its live connection, and the validator applies checks (1)–(4) below and forwards it exactly as one from a job stream; it affects no §10.6 outcome. The Accepted stream rule is a push-delivery rule; it does not give the Accepted validator exclusive control over result-transaction propagation. For verification.runners > 1, the accepted runner MUST send JobResultCommit before JobResult:
tx_bytes is the exact transaction encoding emitted by the shared protocol codec for the coordinated core/runner release. CIP-11 does not define a second transaction format or signing preimage. It has no CBOR body or fixed four-byte CBOR-length prefix; QUIC frame and Submission framing are separate. It is a complete runner-signed transaction envelope, including the instruction, nonce, all limits and fee fields, signer roster, metadata and signatures covered by that release’s codec. The ordinary /submit transaction verifier checks its authenticity, with no additional CIP-11 signature. The commitment, result bytes and salt are obtained from the decoded instruction and are not duplicated as signed frame fields. The wallet-identity release uses Transaction v2 (CURRENT_TX_VERSION = 2, no outer kind byte), as fixed by the pinned shared codec. It does not implement the draft CIP-40 v3/EIP-712 release. When that release ships, these transport rules carry only CIP-40 §7.1’s version=3 ‖ kind=0 ‖ body and use its transaction verifier/digest; kind=1 is not a result transaction. A release accepts only its one current codec version, never both formats. The runner MUST construct and retain the full runner-signed Transaction envelope for each result-phase instruction (SystemInstruction::JobResultCommit and, after the reveal window opens, SystemInstruction::JobResultSubmit) until it observes canonical inclusion, the job reaches a terminal state, or the instruction is no longer valid under the CIP-2 commit/reveal windows. The validator MUST NOT reconstruct, amend, or re-sign these transactions from frame fields. On receipt it MUST decode tx_bytes with the same Transaction::read decoder used by ordinary /submit admission and verify that: (1) the decoded transaction is signed by the runner that sent the frame; (2) the instruction is SystemInstruction::JobResultCommit for JobResultCommit frames or SystemInstruction::JobResultSubmit for JobResult frames; (3) the instruction’s job_id exactly equals the outer frame job_id; (4) the transaction passes the node’s normal size/signature/nonce/gas-cell-limit/fee validation. If any check fails, the frame is invalid and the transaction MUST NOT be forwarded; otherwise the validator forwards the decoded transaction verbatim through the normal transaction-admission path. It MUST NOT mint a new consensus instruction or derive a transaction from individual frame fields. If the runner does not observe inclusion of a signed result-phase transaction within RESULT_TX_INCLUSION_GRACE_BLOCKS (default 2) finalized blocks after sending the corresponding frame, it MUST self-submit or rebroadcast that same runner-signed transaction through the normal transaction-admission path (the /submit mempool path, wrapping tx_bytes in the standard Submission envelope exactly as any client does; the envelope provides transport framing outside tx_bytes, or another validator in Sub(R)). It SHOULD repeat rebroadcast every RESULT_TX_REBROADCAST_INTERVAL_BLOCKS (default 2) blocks until inclusion or terminal expiry. Duplicate admission, duplicate-mempool rejection, or nonce-too-low after observed inclusion are non-failures. Rebroadcast MUST NOT send a reveal before the CIP-2 reveal window opens and MUST NOT alter tx_bytes or any decoded transaction field; if the original transaction was never admitted, a replacement MUST be a new runner-signed transaction envelope with a valid fee/nonce that still satisfies the CIP-2 commit/reveal ordering. For verification.runners == 1 the runner MAY skip the commit and send JobResult directly, but the same retained-transaction and rebroadcast rule applies to that JobResultSubmit. A validator receiving JobResult for a multi-runner job before the commitment is included / reveal window opens MUST hold it or reject with Goodbye { ProtocolError }; it MUST NOT submit an early reveal. Only the Accepted validator receives the push result frames; result-transaction rebroadcast is ordinary mempool propagation (§16.3).

10.4 Streaming Progress (Optional)

RPC clients can report this information. It has no on-chain effect.

10.5 Cancellation

As with JobAck, the validator_pubkey / runner_pubkey in the §12.6 JobCancel preimage are the authenticated connection identities (§6.2); the runner MUST reject a JobCancel whose assignment_hash does not match an in-flight assignment for job_id on that connection. On receipt, the runner MUST stop further execution for that assignment. A JobCancel does not void the §10.3 retained-transaction, reveal-window, or rebroadcast obligations for any result-phase transaction whose commitment was already sent or admitted: after a runner has sent or submitted SystemInstruction::JobResultCommit, it MUST still reveal/rebroadcast as required by §10.3 until canonical inclusion, terminal job state, or instruction expiry (CIP-2 v3 classify_non_reveal has no exception for cancellation, so a runner that commits and then goes silent would be slashed as provably dishonest). If no commitment has been sent or admitted, the runner MUST NOT send new result frames after the cancel; post-cancel transactions are dropped at the validator or rejected by the mempool if another runner already settled.

10.6 Dispatch Outcome Classification

Local-presence floor: a valid HeartbeatPing after a HardFailure restores the entry. None of these touch chain state, the eligibility floor, or another validator’s view; they affect only this validator’s delivery routing and its presence contribution.

11. Failure Handling and Re-selection

11.1 Per-Dispatch Timeout

On HardFailure (§10.6) the validator closes the job stream and clears the runner’s local-presence entry. ACK_TIMEOUT_BLOCKS (default 15) absorbs one bad block plus a heartbeat RTT. Duplicate/SoftFailure do not affect local presence. This fast detection limits a wrongly present runner’s cost to one attempt, with no wait for a job timeout (§7.3).

11.2 Per-Job Timeout

deadline_block is the chain-derived timeout-index block signed in JobAssignment (§10.1). If no SystemInstruction::JobResultSubmit is canonically included by deadline_block, the existing CIP-2 §6 timeout re-selection draws the next committee (excluding timed-out runners) at the next block. The timeout is tied to block height, so all validators advance in lockstep.

11.3 Connection Loss

The validator clears the runner from local presence immediately (routing only); the runner reconnects with backoff (100 ms × 2^attempt, cap 30 s, ±25% jitter). While disconnected from a given validator, other validators in Sub(R) still deliver; when the runner reconnects, that validator re-pushes the runner’s live assignments (§10.1). Eligibility is unaffected (it depends only on the floor). Results whose Accepted stream dropped settle through the §10.3 retained-transaction self-submit.

11.4 Reputation and Slashing

CIP-11 adds no slashing conditions. CIP-2 reputation decay still applies to repeated timeouts.

11.5 In-Flight Jobs Across an Epoch Boundary

A job assigned in epoch E whose deadline_block falls in epoch E+1 drains safely:
  • Settlement is epoch-independent. SystemInstruction::JobResultCommit and SystemInstruction::JobResultSubmit are ordinary runner-signed mempool transactions (§10.3), distinct from the QUIC JobResultCommit / JobResult frames that carry their tx_bytes. They settle regardless of which validator subset is active; an epoch change never invalidates an in-flight job’s settlement path.
  • Delivery survives the boundary. During the OVERLAP_BLOCKS window the runner still holds its Sub_E(R) connections (§5.3), so the dispatching epoch-E validator can continue to receive result frames on the Accepted stream. If that stream drops, the runner MUST use the §10.3 transaction-admission/rebroadcast path for the retained SystemInstruction::JobResultCommit / JobResultSubmit transaction via any epoch-E+1 validator it is now connected to, or via the /submit mempool path.
  • Cancellation. JobCancel for such a job MAY be sent by a validator in either subset during overlap; after the window, only epoch-E+1 validators (or the chain’s timeout re-selection, §11.2) drive cancellation/re-selection.
No job is lost or settled twice at an epoch boundary, because CIP-2 commit-reveal settlement is idempotent.

12. Wire Format

12.1 Frame Encoding

length covers exactly the bytes after the length field, 1 + payload.len() (the type byte plus payload), and does not include the 4-byte length prefix. length == 0, length > MAX_FRAME_BYTES (§13), a truncated frame, an unknown type, or payload bytes that do not decode as the exact §12.2 frame body for type are protocol errors (Goodbye { ProtocolError } if a goodbye can be sent, otherwise close). Every payload is the §12.6 CIP-11 deterministic CBOR profile encoding of the frame’s body fields (excluding the outer length/type). Implementations MUST NOT rely on host-language serializer defaults for map order, enum representation, optional-field representation, or indefinite-length CBOR. Frame body maps have exactly the fields listed by the frame definition, no extension keys in wire version 1; optional fields follow §12.6 optional-field encoding unless a frame-specific preimage helper says otherwise; enum values use the §12.6 discriminant tables. Implementations MUST include cross-stack frame-byte pin tests: for at least Hello, HelloAck, JobAck{Accepted}, JobAck{Reject(UnverifiableAssignment)}, BackpressureSignal, JobAssignment, JobResultCommit, JobResult, WorkloadHintSubscribe, WorkloadHint, and Goodbye, the node-side and runner-side encoders MUST independently produce byte-identical frames, including the 4-byte length prefix, the type byte, and the deterministic-CBOR payload. The fixture set MUST include an enum-with-payload (AckStatus::Reject) and at least one optional string encoded as null and one as text.

12.2 Frame Type Table

CIP-11 adds no consensus vote extension. Presence travels as a committed PresenceInput block field (§7.2). The only inter-validator messaging is the advisory presence gossip a multi-validator Mode-B proposer aggregates (§8.2) and the non-normative observability gossip (§7.5). Mode-A evidence travels in a runner-submitted SubmitPresenceCertificate transaction (§8.3).

12.3 Versioning

Hello.version is a u16 packed as (major << 8) | minor; this specification is version 0x0101 (major 1, minor 1). Minor 1 adds the workload-hint frames 0x30 and 0x31 (§6.7) and changes nothing else. A peer MUST close with Goodbye { UnsupportedVersion } when major differs from its supported major. Backward-compatible additions that do not change existing frame bytes, signature preimages, or required validation rules MUST bump only minor; incompatible changes to frame encoding, frame-type semantics, deterministic-CBOR schemas, or signature preimages MUST bump major. Peers negotiate the minor. The runner’s Hello.version is the highest version it implements. A validator that implements minor m accepts a runner Hello of the same major and any minor, and the negotiated version is the runner’s version with its minor capped at m. The validator’s Hello and HelloAck carry the negotiated version. The runner MUST reject a validator version whose major differs or that exceeds the version it offered, and otherwise MUST use the validator’s version in its own HelloAck. Both HelloAck preimages and the connection_id (§12.6) use the negotiated version. A frame that the negotiated version does not define is a protocol error. A peer that implements only minor 0 rejects any other minor with UnsupportedVersion before authentication. A runner that receives that Goodbye in reply to a Hello above 0x0100 SHOULD reconnect once offering 0x0100, and MAY keep using 0x0100 with that validator until it reconnects for another reason. A 0x0100 session behaves exactly as minor 0 specifies.

12.4 (Reserved)

Reserved.

12.5 Goodbye

Sent after mutual auth: signed MUST be present (§12.6 preimage). Before mutual auth: signed MAY be absent and the frame is advisory only. It MUST NOT affect reputation, presence, or dispatch accounting.

12.6 Signature Domains

CIP-11 application signatures are role-scheme signatures over keccak256(domain ‖ signer_role ‖ scheme_id ‖ canonical_fields): runner-signed frames use recoverable secp256k1 ECDSA (65-byte sig over a 33-byte compressed key); validator-signed frames use Ed25519 (64-byte sig over the validator’s 32-byte peer_pubkey, §3/§5.4). domain is ASCII ending -v1; signer_role and scheme_id are part of the signed bytes; preimage scalar integers are big-endian; every canonical_* byte string in this CIP follows the CIP-11 deterministic CBOR profile defined below, with one exception: job_spec_hash and the JobSpec/JobType encoding it hashes use the shared protocol codec’s binary (commonware-codec) encoding (subsection below). CIP-2 defines no canonical wire encoding, so CIP-11 owns both the CBOR profile and the job_spec_hash recipe. (The per-frame preimages below are each implicitly prefixed by signer_role ‖ scheme_id.) Validator-originated control-plane signatures in all modes use the validator Ed25519 peer identity from the active §5.4 snapshot unless a future CIP defines an epoch-bound delegated control-key authorization (custody per §6.2). Scheme-tagged keys. Every wire public-key field, typed PubKey (e.g. party_pubkey, and every *_pubkey carried in a frame or receipt), is encoded as a 1-byte scheme_id followed by the key bytes: 0x01 identifies secp256k1 with a 33-byte compressed key (34-byte PubKey on the wire); 0x02 identifies Ed25519 with a 32-byte key (33-byte PubKey on the wire). Sig is the matching role-scheme signature (secp256k1 uses 65 bytes; Ed25519 uses 64 bytes). A verifier MUST reject any frame or receipt where scheme_id, key length, signature length, the signer’s party_role/role, and the authoritative source do not all agree: runner authority is RunnerRegistration.address (checked by secp256k1 derived-address equality / recoverable-signature address recovery); validator authority is the §5.4 ValidatorSetSnapshot peer_pubkey. Role-scheme mismatch is a fatal error. Authoritative state keys are raw. The scheme-tagging above applies to wire fields only. Authoritative on-chain/consensus state keys are stored and hashed raw (untagged): the §5.4 ValidatorRecord.peer_pubkey (32-byte Ed25519) and the RunnerRegistration.address (20-byte secp256k1/EVM address). validator_set_hash is computed over the raw validator peer_pubkey bytes (§5.1, §8.3). A wire validator PubKey MUST validate its scheme_id and, after stripping the 1-byte tag, decode bit-for-bit to the authoritative raw peer_pubkey; a wire runner PubKey MUST validate its scheme_id and derive the authoritative RunnerRegistration.address. Within the per-frame preimages below, each *_pubkey denotes the canonical scheme-tagged PubKey encoding (identical to the wire frame bytes); validator_set_hash is the separate hash over the §5.4 snapshot’s raw, untagged peer_pubkey values. CIP-11 deterministic CBOR profile. Every canonical_* byte string is deterministic CBOR per RFC 8949 §4.2.1, plus: definite-length byte/text strings, arrays, and maps only (indefinite-length is invalid); shortest-form integer encodings; maps sorted by deterministic CBOR key encoding with no duplicate keys; text strings are UTF-8 as supplied (no normalization/case-folding/whitespace rewriting); byte strings are raw bytes; finite IEEE-754 binary64 floats encoded as CBOR float64 (NaN/±Inf invalid); JSON values converted recursively (an object becomes a map with sorted text keys, an array remains an array, and an integral-in-range number uses the shortest int encoding while other numbers use float64, etc.). This profile does not produce job_spec_hash or the JobSpec/JobType encoding (see below). CIP-23 §3.5.1a–§3.5.2 additionally adopts this profile as the canonical form for the Job-path result_payload (result.data) and the Deterministic cross-runner byte-match (CIP-2 §9), under the same single-shared-codec + identical-revision-pin + frozen-fixture discipline as §12.6’s cross-stack rule below; the Deterministic byte-match additionally enforces this profile’s no-floats rule (a non-integral binary64 is INVALID). Optional-field encoding. Unless a field-specific preimage helper defines a collapse rule, structural optional fields inside deterministic-CBOR objects (canonical_frame_body and other non-JobSpec canonical_* values covered by this profile) are encoded as CBOR null when absent (empty strings/arrays are distinct from null). The scalar preimage helpers retry_after_blocks_or_zero, canonical_reason_or_empty, and detail_or_empty are explicit exceptions using their helper-specific collapse rules (defined below). JobSpec/JobType optional fields use the shared codec’s Option<T> presence byte instead (below). Canonical JobSpec/JobType encoding. The canonical JobSpec/JobType encoding, and every field nested inside them (ResourceBounds, VerificationConfig, VerifierCheck, CallbackInfo, SecretKeyRef, JobPrecondition, HireBinding, ResultSchema, VolumeAttachment, the same shape as CIP-9’s canonical VolumeAttachment, and the HeaderMap used by http jobs), is a commonware-codec binary encoding produced by one shared protocol codec. node and runner MUST both consume that shared codec directly, and independent implementations of the schema are forbidden. The first byte of every JobType encoding is the §9.4 CIP-11-owned job_kind byte; the shared codec MUST encode this same byte, pinned by a cross-node/runner test exactly as §9.4 requires. The byte layout follows. Any future change to the shared codec MUST preserve two properties: (1) numeric fields that can carry fractional values, JobType::Llm.temperature and the numeric_tolerance/numeric_range verifier check’s tolerance/min/max, are scaled-integer (Milli/Nano) types, never floats, per the whitepaper’s no-floats-in-canonical-encoding rule; (2) http job headers use a HeaderMap that rejects any two keys equal under ASCII case-folding (duplicate_header_key; nothing is merged), with keys sorted by their original-case bytes, which are preserved on the wire, so a Host/host pair (or any other case-variant collision) cannot smuggle two conflicting header entries past validation. JobSpec byte encoding. Fields are positional, with no field tags or padding. Primitive rules:
  • u8, [N]u8, and Address ([20]u8) are raw bytes.
  • varint is unsigned LEB128 (7 data bits per byte, least-significant group first, high bit = continuation). Every u16/u32/u64 field uses it. Decoders reject overlong encodings and values that overflow the field type.
  • bool is one byte, 0x00 or 0x01; any other byte is rejected. Option<T> is a bool presence byte followed by T when present.
  • bytes is varint(len) ‖ len bytes; string is bytes holding UTF-8; Vec<T> is varint(count) ‖ T….
  • Enums are one tag byte followed by the variant’s fields; unknown tags are rejected.
  • json is bytes holding canonical JSON (rules below).
  • Milli is the varint of x × 10³ as u16, range 0..=2000. Nano is the varint of the zigzag ((n << 1) ^ (n >> 63)) of n = x × 10⁹ as i64.
Every length and count has a decode bound (table below), and a longer value is rejected. A full JobSpec decode MUST consume the whole buffer; trailing bytes are rejected. The client wire (JobSubmit) is the version byte followed by every row except the P only and never-encoded rows; a decoder sets those fields to zero. P (below) is the rows from job_id through result_schema in table order, without the version byte. Tags 0x09 and above are rejected. Nested types: PrivateHttp (tag 0x08) carries no request or response bytes; both are objects in the owner’s private CBFS volume. HttpBodyRef names an existing encrypted object: owner is nonzero, every [32]u8 field is nonzero, and digest = SHA-256("cowboy/private-http-reference/v1" ‖ 0x00 ‖ volume_id ‖ manifest_root ‖ object_id ‖ u32be(size_bytes)). HttpResponseRef names the destination for the response: owner, volume_id and object_id are nonzero. A reference that breaks any of these rules fails the decode. Both resolve object_id to the object key private-http/<hex(object_id)>.bin inside the named volume. AgentModeV1 and RuntimeConfig (inside tags 0x05 and 0x06): RouteInvocation.descriptor (inside tag 0x07) is one deterministic CBOR map in the CIP-11 profile above, carried as bytes. The map has exactly the 14 keys below; an extra, missing, or repeated key rejects, and a null value is written as 0xf6, never omitted. Keys are text strings sorted by their encoded bytes (shorter key first, then bytewise). uint is a CBOR unsigned integer in shortest form; bstr[N] is a CBOR byte string of exactly N bytes. No other CBOR major type, tag, float, or indefinite length is accepted, and the descriptor MUST be the whole bytes payload. Nested maps follow the same rules: SessionOpen.id MUST equal the session ID SHA-256("cowboy/route-session/v1" ‖ 0x83 ‖ uint(chain_id) ‖ bstr(actor) ‖ bstr(nonce)), the deterministic CBOR encoding of the array [chain_id, actor, nonce]. A retry reuses its nonce and therefore its session ID. The descriptor is structural only: a decodable descriptor grants no authority, and admission still checks route policy, budget, deadlines, the hire, replay and assignment. Decode bounds. The decoder checks each bound against the length or count prefix before reading the payload. A value past its bound, a string that is not UTF-8, or a value outside a stated grammar fails the decode: a JobSubmit carrying it is rejected, and a JobAssignment carrying it is Reject(UnverifiableAssignment). Lengths are in bytes. Canonical JSON. A json field holds exactly one canonical JSON text, defined as follows:
  • UTF-8 only. One value (object, array, string, integer, true, false, null) and nothing after it.
  • No whitespace between tokens.
  • Object members are sorted ascending by the UTF-8 bytes of the unescaped key. Two keys that are equal after unescaping are rejected.
  • Array elements keep their order.
  • Numbers are integers only: -?(0|[1-9][0-9]*), within the i128 range. A fraction, an exponent, -0, and leading zeros are rejected.
  • Strings escape exactly \", \\, \n, \r, \t, \b, \f; every other code point in U+0000 to U+001F is \u00xx with lowercase hex. All other characters, including /, U+007F, and non-ASCII, are written literally. Raw control bytes, unknown escapes, and unpaired surrogates are rejected.
  • A value nested inside more than 64 objects and arrays is rejected.
The decoder parses the body (it accepts insignificant whitespace, any key order, and any valid escape spelling), produces the canonical text above, and rejects the field unless that text is byte-identical to the body. A wire json field is therefore always already canonical. job_spec_hash.
JOB_SPEC_VERSION is the JobSpec wire-format version byte (currently 6), included as its own preimage byte, P does not re-prepend it. P is the canonical encoding of the JobSpec’s fields in struct/wire order, job_id, job_type, bounds, verification, max_price, tip, timeout_blocks, callback, submitter, submitted_at, required_runner_pool, attachments, secret_refs, precondition, hire_binding, result_schema, computed by the node, after it has stamped job_id, submitter, and submitted_at onto the spec AND after any chain-side mutation of the spec, specifically the adaptive committee override (CIP-2 §5.1; the dispatcher rewrites the stored spec’s verification.runners/verification.threshold to the adaptively-sized committee before dispatch), both of which P covers. job_spec_hash therefore commits to the final dispatched spec (the one placed in the runner’s JobAssignment), NOT the admission-time value: a runner verifies job_spec_hash against the spec it is asked to execute, so a hash taken before the committee override would spuriously mismatch on every M > 1 job the override adjusts. This differs from the client-submission wire: the client wire omits all four node-generated fields (job_id, submitter, submitted_at, req_hash), whereas P includes job_id/submitter/submitted_at and excludes req_hash and run_root. req_hash is a digest of part of the spec, so hashing it again adds no coverage. run_root identifies run lineage and is not a term of the job. The three stamped identity fields and the committee override are the only chain-side writes that enter P. Dispatcher-resolved runtime grants, the resolved VolumeAttachment.relay_endpoints and erasure parameters delivered to the runner alongside its assignment (CIP-9 §8.1), MUST NOT rewrite the stored spec and MUST NOT enter P: attachments are hashed exactly as the client submitted them. A submitter can therefore predict the hash of its own spec, apart from the stamped fields and the committee override, and relay churn or re-resolution cannot move it. P encodes every field except req_hash and run_root, so job_spec_hash binds secret_refs, precondition, hire_binding and result_schema, and inherits the scaled-integer numerics and case-insensitive HeaderMap above. A runner MUST verify job_spec_hash against this formula before executing, and MUST treat a mismatch as Reject(UnverifiableAssignment). On the wire, the JobAssignment frame carries job_spec as an opaque CBOR byte string whose contents are the canonical JobSpec encoding of the final dispatched spec: the §12.1/§12.2 frame envelope remains this profile’s CBOR, but the job_spec bytes inside it are codec bytes. There is exactly one JobSpec byte representation, and it is the hashed one. A runner MUST verify job_spec_hash over the received bytes exactly as carried (per the formula above) and decode them with its pinned shared codec; a hash mismatch or a decode failure is Reject(UnverifiableAssignment). Recomputing the hash from a re-encoded local struct is non-conforming. The retained received bytes are the canonical bytes, so a lossy decode and re-encode cannot change what was hashed. Cross-stack drift. Because node and runner consume the same shared codec, two independent encoders cannot disagree on JobSpec bytes. Implementations MUST instead pin node and runner to the same shared-codec revision, so job_spec_hash cannot silently diverge via a stale dependency, and MUST include a frozen job_spec_hash fixture test, a checked-in JobSpec with its expected hash bytes, so a codec upgrade that changes canonical bytes fails and exposes any network-wide change to the hash (the same-version pin only guards node-vs-runner skew. It does not guard a lockstep upgrade to changed bytes). A codec change that alters the canonical JobSpec/JobType bytes or either hash recipe is a consensus change: it MUST bump JOB_SPEC_VERSION and MUST be ratified as a CIP-11 amendment before deployment, because the codec implements this encoding and does not define it. A change adopted only by networks started from a fresh genesis that carries it from the first block MAY keep JOB_SPEC_VERSION, since no spec encoded the earlier way exists on such a network; it still requires the amendment and an updated frozen fixture. Enum discriminant bytes. Every enum discriminant hashed into a §12.6 preimage is a CIP-11-owned stable consensus byte, authoritative independent of any Rust source-order discriminant. These four control-plane enums are not yet implemented in node/runner; when implemented, an implementation MUST pin this table with a test against both the node and runner definitions (exactly as §9.4 pins job_kind), so source-order divergence, already demonstrated by JobType, where Agent is source-index 5 in node but 3 in runner, cannot silently change a signed byte. New variants MUST be appended with the next free byte.
Unpinned preimage components. Components without an explicit length/encoding in the structs above, but hashed into a signed (and, in Mode A, on-chain-verified) preimage, MUST use these pinned wire representations so preimages are bit-for-bit identical across implementations:
  • signer_role / any Role: 1 byte (Runner = 0x01, Validator = 0x02).
  • accepting_new (bool, in HeartbeatPong/PresenceReceipt): 1 byte (false = 0x00, true = 0x01).
  • retry_after_blocks_or_zero (Option<u64> in Goodbye): 8 bytes big-endian; None collapses to 0 (0x0000000000000000), the deliberate None ≡ Some(0) collapse.
  • canonical_reason_or_empty / detail_or_empty (Option<String>): the §12.6 “CIP-11 deterministic CBOR profile” text-string encoding; None first collapses to the zero-length text string "", then encodes, so None/empty hashes the deterministic-CBOR empty text value (0x60). Neither raw zero bytes nor a CIP-2 encoding applies.
canonical_frame_body. For the cowboy-cip11-control-v1 domain (BackpressureSignal, §6.4; CapabilityDelta, §6.5), canonical_frame_body is the §12.6 “CIP-11 deterministic CBOR profile” encoding of the frame’s payload fields with the signed field omitted. Encoders MUST omit signed entirely (not zero-fill it); verifiers reconstruct the same byte string before checking the signature. canonical_reason_or_empty / detail_or_empty. canonical_reason_or_empty encodes JobAck.reason: Option<String> and detail_or_empty encodes Goodbye.detail: Option<String>, both with the collapse rule above. A present value MUST be encoded exactly as its UTF-8 text with no trimming, normalization, case folding, or implementation-local transformation before hashing. Preimage field origins. Several preimages name chain_id and *_pubkey values that come from the connection. For any preimage that includes chain_id while the frame body omits it (notably JobAssignment), chain_id is the authenticated chain_id established by the accepted Hello/HelloAck for this QUIC connection (§6.2); signers and verifiers MUST use that connection-bound value, and verification with any other chain_id MUST fail. Likewise the runner_pubkey / validator_pubkey named in preimages are the connection’s bound peer identities (the same values folded into connection_id). They add no wire fields. JobResultCommit and JobResult define no additional CIP-11 application signature. Their authenticity is the ordinary chain transaction signature carried inside tx_bytes (over the shared release-codec signing digest, §3.3 and §10.3) for SystemInstruction::JobResultCommit / JobResultSubmit; the validator decodes tx_bytes with the node Transaction::read decoder and forwards it verbatim (§10.3), preserving the existing mempool/verifier path. The Mode-A SubmitPresenceCertificate carries dedicated PresenceReceipt signatures (the cowboy-cip11-presence-receipt-v1 domain above) plus the ordinary chain transaction signature for the submission itself. Unsigned / externally-signed frames. Hello is unsigned (it is the challenge half of the challenge-response; identity is proven by the subsequent signed HelloAck). JobProgress is informational and unsigned. WorkloadHintSubscribe and WorkloadHint are unsigned: they travel only on an admitted control stream, and a hint is advisory (§6.7). JobResultCommit / JobResult carry no frame signature, because the transaction in tx_bytes carries its own. All other frames in §12.2 have a signature preimage in this section.

13. System Constants

Non-reserved constants SHOULD be governance-adjustable (CIP-12); _BLOCKS defaults assume the 1 s block target. Protocol flags (boolean protocol-parameters, all default false/off; each flipped by a CIP-12 governance vote, §14): All three flags MUST be mapped to canonical cowboy-node protocol parameters with stable ParamKey names and bound to a CIP-12 governance tier before activation (CIP-12 §5.1’s tier list does not yet enumerate CIP-11; this binding is a CIP-12 follow-up). Each flip is a CIP-12 governance vote (§14).

14. Delivery Path and Selection Flags

CIP-11 push (§10.1) is the only job delivery path, and result frames on the Accepted stream (§10.3) are the only result path. The §10.3 retained-transaction self-submit guarantees inclusion of those runner-signed transactions. Only authenticated pushes enter execution. GET /runner/{address}/jobs serves only a pushed job’s volume attachments (§18). A runner MUST NOT start without a validator QUIC endpoint. A runner that cannot reach its validator subset receives no work until it reconnects. On reconnect the validator re-pushes its live assignments (§10.1). The §11.1 ack timeout and §11.2 timeout re-selection recover an assignment that never reaches the runner. No flag gates the QUIC transport. The §13 flags govern presence-driven selection, and a CIP-12 governance vote flips each one. Launch is single-validator (§8.1).
  • With CIP11_PRESENCE_SHADOW_ENABLED, proposers SHOULD populate PresenceInput and the present-first draw is computed on a side path for telemetry only; live selection uses an empty present pool. While CIP11_PRESENT_FIRST_ENABLED is false, the field MAY be absent or malformed without invalidating the block, and execution MUST treat the present set as empty outside shadow metrics (§7.2).
  • With CIP11_PRESENT_FIRST_ENABLED, present-first/fail-open selection (§7.3) is enforced using a committed PresenceInput. In active Mode B this is a required, well-formed block field (§7.2); in active Mode A the proposer field is ignored and PresenceInput is derived from parent-state certificates (§8.3). The eligibility floor (§9.1) remains the normative, tuned HEARTBEAT_TIMEOUT_BLOCKS check.
  • Governance MAY widen HEARTBEAT_TIMEOUT_BLOCKS/heartbeat cadence to reclaim bandwidth (push/ack provides fast liveness).
These flags do not gate MRU (§9.4), v3 seed timing or commit-then-reveal selection (§9.2).
  • A static multi-validator genesis needs no new consensus mechanism, because Mode B uses the same proposer-supplied presence (§8.2).
  • Changing the validator set over time (E → E+1) waits on the §5.4 reconfiguration mechanism. CIP-11’s subset rotation and OVERLAP_BLOCKS window (§5.3) then apply automatically. Governance enables Mode A only if it wants censorship-resistant hard exclusion (§8.3).

15. Native Runner Routes

A native runner route is an HTTP endpoint that an actor publishes in its CIP-15 routes table and sponsors itself. Invoking it opens a metered session on one runner. The chain admits the session against the actor’s declaration and sponsorship ceilings, escrows the session budget from the actor’s balance, and assigns a parent job that reaches the runner by push (§10.1). The chain carries admission, the runner’s session reports, close and settlement. It does not carry the session’s requests or responses.

15.1 Route Declaration

A RouteDeclaration is a fixed-schema map in the §12.6 deterministic CBOR profile. Its encoded size MUST NOT exceed MAX_DECLARATION_BYTES, and it MUST carry exactly the fields below; unknown, missing or duplicate keys are invalid.
uint is an unsigned integer of at most 64 bits and uint32 of at most 32. wei is a 16-byte big-endian byte string holding a u128 amount in wei. bytesN is a byte string of exactly N bytes. An absent optional value is CBOR null. Each VolumeAttachment and SecretKeyRef element is a byte string holding that type’s canonical shared-codec encoding (§12.6), which MUST re-encode to the same bytes; a SecretKeyRef is 52 bytes, account ‖ key_hash (CIP-24). A declaration is valid iff all of the following hold:
  • path starts with /, is neither /_cowboy nor under /_cowboy/, and contains no control character, ? or #. handler contains no control character.
  • kinds is non-empty and strictly ascending, and contains 1 iff it contains 2. A declaration that contains them is a session declaration.
  • In limits, first_byte_ms, idle_ms, wall_ms, memory_bytes and max_concurrency are nonzero, and first_byte_ms and idle_ms are each ≤ wall_ms.
  • In sponsorship, window_blocks, admissions_per_window and max_active_jobs are nonzero.
  • A session declaration has nonzero lifetime_blocks, idle_ms, max_requests, max_concurrency, max_tokens and drain_ms in session_limits, 1 ≤ reorder_window ≤ 1024, session_limits.max_concurrency ≤ reorder_window, nonzero sponsorship.max_active_sessions, and a metering_key.
  • Unless pricing.allow_zero, limits.max_job_budget, sponsorship.max_reserved_wei and sponsorship.max_admitted_wei_per_window are nonzero, as is session_limits.max_budget in a session declaration.
  • metering_key.public_key begins with 0x02 or 0x03.
  • mounts and forward_headers each have at most 64 entries. read_keys, verify_keys, sign_keys and the metering key’s secret_ref together hold at most 1024 references, and no reference appears twice among them.
  • mounts, read_keys, verify_keys, sign_keys and forward_headers are each strictly ascending by encoded bytes.
  • Each forward header is 1–128 bytes of lowercase ASCII letters, digits and !#$%&'*+-.^_`|~, does not begin with x-cowboy-, and is none of connection, keep-alive, proxy-authenticate, proxy-authorization, te, trailer, transfer-encoding, upgrade, host, content-length.
Decoding accepts only bytes that decode under this schema with nothing trailing and satisfy every rule; it never normalizes. bundle_hash and runtime_hash identify the runner code and runtime the route executes; they are copied into the parent job (§15.5). mounts become the parent job’s CIP-9 attachments. read_keys, verify_keys, sign_keys and metering_key.secret_ref are the only CBSS secrets the assigned runner may obtain for the session, each under its own purpose (§15.6). limits bound a single request and session_limits bound one session. The chain checks handler, auth, response_mode, forward_headers and the timing limits for structure only and carries them, pinned, to the executor; it additionally checks that ingress_verify_key is a valid Ed25519 point that is not of small order (§15.5). A declaration MAY list kind 0, but a per-call invocation is always refused (§15.4). Only sessions are admitted.

15.2 Route ID and Table Entry

declaration_bytes is the declaration’s canonical encoding (§15.1). Every field enters the hash, so changing any of them, including instance values such as mount owners, secret references, the metering key or the bundle hash, yields a different route. A declaration is published as a CIP-15 route whose target is RunnerRoute { kind: "runner_route", declaration: declaration_bytes }, with declaration encoded as a CBOR byte string and no other target field. The outer route MUST have the declaration’s verb, path and enabled, MUST carry pays = "actor" and enabled explicitly, and MUST NOT carry price, mode, timeout_ms or fallback_response. ANY is never a native route verb. (verb, path) is unique within the table (CIP-15 §6.8). The Gateway does not dispatch runner_route entries. They exist for admission under this section, and the Gateway serves the rest of the table under CIP-15.

15.3 Sponsorship Ceilings

Two ceilings bound what invocations may draw from an actor: the actor-wide ceiling at __cowboy/route_sponsorship, and the sponsorship field of each declaration. Both have one schema:
The actor-wide ceiling is the canonical encoding of exactly these six fields, at most MAX_SPONSORSHIP_BYTES, with nothing trailing and nonzero window_blocks. Its zero quotas are valid and deny capacity. It is present iff the actor’s routes table contains at least one runner_route entry. Both slots are installed only by the chain, from the RouteInstall { table, sponsorship } carried on DeployActor, UpgradeActor or upgrade_self (CIP-15 §6.9). An install whose table has a runner_route entry and no sponsorship, or a sponsorship and no runner_route entry, is invalid. Declarations carry per-instance values: mount owners, secret references, the metering key, bundle and runtime hashes. The deploying tool supplies them in the table at deploy, or with an upgrade through upgrade_self. An actor’s address derives from its deployer, salt and code hash and not from its routes, so a provisioner can compute the address and bake actor-scoped references into the declarations before it deploys. Usage. The Job Dispatcher keeps one usage row per actor and one per (actor, route_id), each holding window_index, admissions, admitted_wei, active_jobs, active_sessions and reserved_wei, with window_index = floor(height / window_blocks) of the governing ceiling. When the window index or the ceiling’s window_blocks changes, admissions and admitted_wei reset to zero; the active and reserved counters never reset. A session admission with budget b adds 1 to admissions, active_jobs and active_sessions, and adds b to admitted_wei and reserved_wei. The actor row checked against the actor-wide ceiling and the route row checked against the declaration’s ceiling MUST each stay within admissions_per_window, max_admitted_wei_per_window, max_active_jobs, max_active_sessions and max_reserved_wei. Settling a session releases its active and reserved amounts. It never refunds admissions or admitted_wei.

15.4 Invocation

A native runner route is invoked only by SystemInstruction::RouteInvocation (system opcode 221), which carries a canonical descriptor. JobSubmit refuses the native job kind, and the Gateway builds no descriptor (§15.2).
The descriptor is a fixed-schema map in the §12.6 profile, at most MAX_DESCRIPTOR_BYTES. session is null for kind 0, a SessionOpen for kind 1, and { id } for kind 2. For a session-open, id = SHA-256("cowboy/route-session/v1" ‖ 0x83 ‖ cbor_uint(chain_id) ‖ cbor_bytes(actor) ‖ cbor_bytes(nonce)), and expires_at, max_requests and max_concurrency are nonzero. A session-close has budget_cap = 0. agent_template_locator is present iff agent_template_digest is nonzero, only on a session-open, with v = 1 and nonzero room_id and seat_id. body_commit and context_commit travel unchanged in the parent job. budget_cap MUST fit in a u64. A per-call descriptor is refused before any state access. Any account MAY submit a session-open, and it pays only the outer transaction’s gas. The actor funds the session (§15.5). A session-open that carries a room locator is valid only when its sender is the current provider of the room’s stream and the seat’s principal is the actor. A replay row keyed by (chain_id, actor, nonce) makes admission idempotent: an exact retry returns the original receipt, and any other descriptor that reuses the nonce is refused.

15.5 Admission

A session-open is admitted iff all of the following hold:
  1. chain_id is the executing chain’s, the nonce is unused, and the block height is ≤ valid_until.
  2. The actor exists, is not rent-dormant and is not paused.
  3. __cowboy/routes decodes under strict admission decoding and has a runner_route entry whose route_id equals the descriptor’s. __cowboy/route_sponsorship is present and decodes (§15.3).
  4. The declaration is enabled and lists kind 1. budget_cap is nonzero unless pricing.allow_zero.
  5. For both the actor-wide ceiling and the declaration’s ceiling, admissions_per_window, max_active_jobs and max_active_sessions are nonzero, and budget_cap is ≤ max_reserved_wei and ≤ max_admitted_wei_per_window.
  6. height < expires_at ≤ height + session_limits.lifetime_blocks; from E2’s height, the remaining lifetime MUST also fit the chain’s current governance ceiling (compiled default 86,400 blocks). Refuse an over-ceiling signed open; do not rewrite it. max_requests, max_concurrency and max_tokens are each ≤ the matching session_limits field, and max_tokens is nonzero. price_advert_digest equals pricing.price_advert_digest, and budget_cap ≤ session_limits.max_budget.
  7. ingress_verify_key, if present, is a valid Ed25519 point not of small order, and metering_key.public_key is a valid secp256k1 point.
  8. hire, if present, names a valid hire of the actor (CIP-33).
  9. The structural access class fits the Runner lane, which admits at most 47 mounts with a hire and 48 without, and the parent job is a valid JobSpec.
  10. Both usage rows admit the session (§15.3), and the actor’s balance covers budget_cap. From F’s height, admission additionally records and counts the seat actor’s CIP-37 ActorOwner account against its concurrent-session cap, including reconciling sessions (compiled default 32); pre-height sessions remain the fixed uncounted legacy group. The actor MUST NOT be the SessionActor or the Job Dispatcher.
An admitted session moves budget_cap from the actor’s balance into SessionActor escrow, assigns the parent job, pins the declaration (§15.6), writes both usage rows and the session record, and records the replay receipt. All of it happens in one transaction; a refusal leaves no effect. The parent job is JobType::RouteInvocation { descriptor, bundle_hash, runtime_hash } with job_id = SHA-256("cowboy/route-job/v1" ‖ descriptor_bytes). The actor is its submitter and callback actor. It has VerificationMode::None with one runner, selected immediately (§9.2) from runners that advertise the route_invocation job kind, and it reaches that runner by push (§10.1). Its max_price is budget_cap, its timeout_blocks is expires_at − height, its attachments are mounts, its secret_refs are read_keys, and its per-request bounds come from limits. It carries no on-chain result payload.

15.6 Session Pinning

Admission pins the canonical declaration bytes under the Job Dispatcher, together with the descriptor hash, the escrow and the admission height. The session record binds route_id, the SHA-256 of the pinned declaration, the metering key and its CBSS version, price_advert_digest, the assigned runner and the session’s aggregate caps (each per-request limit × max_requests). From then on, no rule that governs the session reads __cowboy/routes or __cowboy/route_sponsorship. An upgrade that replaces or removes them (CIP-15 §6.9) leaves every open session on the declaration it was admitted under; only later session-opens see the new table.
  • Reports. The assigned runner reports with a JobResultSubmit whose result is a canonical SessionReport, sent as the §10.3 native session report. Each report carries an EIP-712 voucher signed by the pinned metering key. Its nonce MUST increase, its usage counters and cumulative amount MUST NOT decrease, and its cumulative amount MUST NOT exceed the escrow.
  • Secrets. A CBSS release for the session is authorized only to the assigned runner. Its purpose is fixed by the pinned declaration: the metering key releases for Metering, read_keys for Read, verify_keys for Verify and sign_keys for Sign. Every other secret is denied.
  • Close. SessionClose resolves the pinned session, never the current table. Its descriptor’s chain_id, actor, route_id and hire MUST equal the session binding, and it carries no agent template. Its sender MUST be the actor or the account that submitted the session-open, and the block height MUST be ≤ its valid_until; it has its own replay receipt. Closing ends execution and starts settlement from the pinned state. A session also closes when it reaches expires_at. From E1’s height, an accepted final report starts closing even before expiry/cap exhaustion; a session already carrying final_seen at the height closes on its next authenticated explicit touch. E3 additionally permits a separately authorized runner-signed session release. Each path preserves reconciliation and releases counters exactly once.

15.7 Pricing

The declaration fixes the price. pricing.price_advert_digest = keccak256(PriceAdvertV1), where PriceAdvertV1 is 64 bytes: llm_input_token_wei, llm_output_token_wei, http_call_wei and mcp_call_wei, each a big-endian u128. Every session-open MUST carry the same digest; the advert itself stays off chain. Native route invocation never consults the CIP-18 price_table, and the CIP-15 entry carries no price (§15.2). The escrowed budget_cap bounds what a session can be charged, and it is zero only under pricing.allow_zero. Settlement pays the reported cumulative amount from escrow and refunds the remainder to the actor.

15.8 Constants


15.9 Room Wake Sessions

A native room seat’s sessions are opened by the room’s CBQS stream provider, which is the admitting relayer (§15.6 Close), from a wake template the seat’s actor signed. The template carries a SessionOpen descriptor with placeholders, and each wake fills them in.
  • Template. The template descriptor has a zero nonce, and its session.id is derived from that zero nonce. Its expires_at is the template’s expiry: the latest height at which any session opened from it may expire. Its valid_until bounds admission (§15.5 rule 1).
  • Opened session. The provider sets a fresh nonce, derives session.id from it, and sets expires_at = min(template.expires_at, h + lifetime_blocks) below E2. From E2’s height, it instead uses min(template.expires_at, h + min(lifetime_blocks, current_chain_ceiling)) and refreshes the ceiling on every wake before signing. Here h is the finalized height at which it authorized the wake. lifetime_blocks is the session_limits.lifetime_blocks of the declaration whose route_id the descriptor names, read from the actor’s installed __cowboy/routes. The route id is the hash of the declaration, so any copy that matches it is that declaration. The open lands at or after h, so §15.5 rule 6 holds. Every other field is the template’s.
  • Commitment. The room-session descriptor commitment, which the template’s Agent child binds, is SHA-256 over the descriptor’s canonical encoding with the zero nonce and the session id derived from it, expires_at = 2^64 − 1, and a zero agent_template_digest. It therefore binds neither a session’s own expiry nor the template’s.
  • Runner check. A runner accepts a parent as opened from its signed template iff the parent, with those placeholders restored and expires_at set to the template’s, equals the template descriptor, and the parent’s expires_at is at most the template’s. A session can expire before its template does, never after it.
  • Provisioning. Room routes declare lifetime_blocks = 86,400, a day at 1 s blocks. The template’s expiry can be far out. A session that nothing closes still frees its runner’s job slot within the lifetime. A new open obeys E2’s ceiling when active; already-open sessions keep their signed expiry.
Idle and unserved sessions. Before E3, only the actor or the admitting provider can close a session (§15.6); the runner cannot. From E3, the runner can submit the separately authorized ReleaseRouteSession. Without a close, a session nobody uses would otherwise hold its runner’s job slot until it expires.
  • Runner. After 10 minutes without a delivery, the session’s consumer stops consuming. It closes its inbox subscription, and from then on it reconnects without subscribing. Once the session is closed it settles the session as closed: it submits what it retained, then the final report. If closing the subscription turns up deliveries the broker had already leased to it, the consumer subscribes again before it processes them, so the seat counts as consumed while the work runs. It retries the subscription with capped exponential backoff, from 1 s doubling to 30 s for about a minute in all, and extends the leases before each wait. If it still cannot subscribe, or cannot extend, it returns the work with CBQS Release (CIP-39 §9.2), unprocessed and with its attempts refunded.
  • Provider. It closes its own execution-live session with SessionClose in two cases. First, when the seat’s inbox group has had no consumer for 120 s, whether or not a record is waiting, and the session is past the 30-block connect grace below (idle). Second, when a wake finds a record waiting behind a live session that nobody consumes, once the session is 30 blocks past its open and its last consumer left more than 30 s ago (unserved). A later record opens a new session as usual.
  • Close fence. A provider-side close MUST NOT end a session a consumer has started serving.
    • The check. Immediately before the close is journaled, the provider checks, under the same lock its broker takes to register a subscription, that the group has no consumer, has had no new subscription since the probe the decision was made from, and lost its last consumer no more recently than the quiet window (0 for the idle close, 30 s for the unserved one). Only then does it mark the group closing.
    • While closing. The broker refuses every new subscription to the group with Backpressure until the close resolves.
    • How a close resolves. The fence is held, through an uncertain send and every rebroadcast, until one of three things happens. The close’s receipt resolves (it landed or failed on execution). The payer’s account nonce moves past the close’s nonce with no receipt for it, so another transaction took the nonce and the close can never land. Or the session’s on-chain expires_at passes, so the close no longer matters. A refused or rejected rebroadcast, or a close with no replacements left, does not resolve it: a duplicate’s rejection can mean the original is still in the mempool, so the provider logs it and keeps the fence. With room lifetimes bounded as above, a seat stays fenced for at most about a day. A provider restarted with a close pending marks that group closing before it serves any connection, so the pending close records its group and its session’s expiry.

16. Security Considerations

16.1 Sybil Connection Storms

The §5.2 DoS gate (reject connections from runners not in the deterministic subset) bounds storms to k per registered identity, each costing a registration and MIN_STAKE_CBY_WEI. Hint-only connections of bound slots (§6.7) have no registration of their own; each validator charges them to the slot’s host and caps them at MAX_HINT_CONNECTIONS_PER_HOST per host and MAX_HINT_CONNECTIONS in total, so the host’s single stake still bounds them. The checks are local and need no consensus.

16.2 Presence Integrity, Censorship, and Mode Dependence

  • Eligibility floor resilience. Selection eligibility is the runner’s own on-chain heartbeat (§7.1), canonical chain state no validator can forge or directly write. Floor freshness depends on heartbeat-transaction inclusion, so the launch sole validator or an inclusion-controlling majority can floor-exclude a runner by censoring it for HEARTBEAT_TIMEOUT_BLOCKS (=100); but under mandatory proposer rotation no BFT minority can sustain 100 consecutive censoring proposers (probability ≈ γ¹⁰⁰). Presence can only order/route within eligible runners (§7.3), so no validator or coalition can make an eligible runner ineligible in the default mode. A proposer can still deny a specific runner work via suppression when the present pool can fill the committee, but this slot-steering is bounded by proposer rotation and removed for runners>1 by §16.9.
  • Single validator (f = 0), explicit trust assumption. The lone validator controls selection, delivery, MRU and presence, so it is fully trusted at launch. A malicious operator could favor its own runners or extract MEV. This is acceptable only because the launch operator is the network operator. Multi-validator (Mode B) removes this single point of trust; an operator running its own runner SHOULD be subject to the governance conflict-of-interest expectations noted in §17.
  • Multi-validator default (B). Fabrication (mark offline-present) self-heals via push timeout; suppression (mark online-absent) only de-prioritizes (the runner stays in the fallback pool). Secure at bounded k.
  • Multi-validator hard-exclude (A). If governance enables A, suppression can censor, so A is sound only with honest-majority subsets (large k, §8.4); this is the documented cost of the strict semantics.

16.3 Delivery Griefing

A Byzantine validator in Sub(R) may refuse to push or push a forged assignment. Mitigations for assignment/push-direction griefing: k-fold push redundancy; timeout re-selection; and runner-side verification of full JobAssignment coverage + finalized assignment_height before executing (§10.1). Worst case for that direction is added latency, self-healed; it does not by itself alter settlement or eligibility. Result-direction griefing is sharper: because §10.3 sends result frames only on the Accepted stream, a Byzantine Accepted validator could withhold the runner-signed JobResultCommit / JobResultSubmit transaction. Under CIP-2 v3 §5, commit-without-reveal is a proven-dishonesty path absent a valid CrashAttestation, so unmitigated this could affect settlement and create non-reveal slash exposure. CIP-11 therefore requires the runner to retain and self-submit/rebroadcast its own signed result-phase transactions if inclusion is not observed within RESULT_TX_INCLUSION_GRACE_BLOCKS (§10.3). This fallback is moot under the single-validator launch trust model but is REQUIRED before multi-validator operation; it is ordinary mempool propagation of the runner’s own signed transaction and does not bypass commit-reveal ordering or mint a second consensus instruction.

16.4 MEV / MRU Front-Running

The MRU multiplier biases iteration 0 only (default 4×), including the first seat of multi-runner and PublishChainRoot committees for the same relayer submitter; a validator-operated runner must first legitimately complete a job to become MRU. Failure mode is bounded work concentration, capped by the multiplier. Two interactions to monitor: (a) present-first selection intentionally favors live runners over pure stake-proportionality (CIP-2), trading some allocation fairness for the active-runner UX. The fallback pool still routes work when present runners are scarce, and a future revision MAY replace strict pool ordering with a weighted boost (e.g. ×1.5) if concentration is observed, which would need a new governance parameter (§16.9 bounds proposer steering separately); (b) because the CIP-2 v3 base weight uses effective_stake · sqrt(reputation) (and effective_stake includes delegation), a runner could farm delegation to amplify the MRU draw. Governance MAY restrict the MRU multiplier to registration.stake and/or tie CIP-13 slashing to peak delegation if this is abused.

16.5 Connection Hijack and MITM

App-layer role-scheme proofs (runner secp256k1 / validator Ed25519) bound to the TLS channel via the exporter (§6.2, §12.6) prevent hijack and proxy replay without the private key. CIP-11 identity does not depend on the TLS certificate algorithm.

16.6 Plaintext Wire (Closed)

QUIC with TLS 1.3 encrypts sensitive job content, such as LLM prompts and signed PublishChainRoot payloads, that plaintext HTTP polling exposed.

16.7 Presence-Evidence Authenticity (Multi-Validator)

PresenceInput trust is mode-dependent. In Mode B it is proposer-supplied and best-effort, and fail-open bounds the damage (§8.2), so no on-chain verification is needed. Only Mode A (opt-in hard-exclude) makes presence able to exclude, and therefore requires the consensus-verified certificate state (§8.3) checked against the live §5.4 validator-set snapshot. Runner-submitted certificates leave no finalization votes for a proposer to cherry-pick; a proposer can still censor/delay a certificate transaction, which under Mode A is why hard-exclude must be paired with subset redundancy (k) and is gated behind governance (§8.4).

16.8 PresenceInput and Reorgs

PresenceInput is committed in the block (§7.2), so a reorg re-derives presence deterministically from the reorged block, the committed bytes (Mode B) or the reorged presence_proven_until state (Mode A). Job selection in block H always consumes the PresenceInput committed in that canonical block (§7.2), so presence needs no separate replay mitigation.

16.9 Proposer Present-Set Steering and Submitter Grinding (Mode B)

Fail-open (§7.3) protects eligibility but not committee membership. In multi-validator Mode B the proposer supplies PresenceInput, and a present-first draw can fill the committee from the present pool. A proposer that marks only a colluding set present can therefore fill up to M committee slots with chosen runners, all still floor-eligible. Multi-runner verification modes (MajorityVote/StructuredMatch/Deterministic/SemanticSimilarity) assume independently selected committee members. A proposer that packs the committee with colluders reduces them to single-proposer trust. In multi-validator Mode B, CIP-11 therefore draws M > 1 membership by VRF over the full floor-eligible set (§7.3, §9.2), and presence only routes delivery (§7.4). That restores independence only if neither the proposer nor the submitter can grind the seed. CIP-11 therefore uses commit-then-reveal over an absolute future consensus round (§9.2):
  • M == 1: select immediately in submission block S using parent beacon R_{S-1}. This preserves latency for None / EconomicBond jobs.
  • M > 1: bind the job in block S and select from the seed of an absolute future round r_seed = advance_round(r_submit, K), where r_submit is the round in which S was proposed and K = SELECTION_SEED_DELAY_VIEWS.
For an activated deployment that satisfies the SELECTION_SEED_DELAY_VIEWS invariant (§9.2/§13), M > 1 CIP-11 selection removes proposer present-set steering from committee membership and closes the CIP-11-specific submitter/proposer grinding path. The submitter can choose job bytes before inclusion in S but, under the activation invariant, cannot know the seed for r_seed before block S is finalized and the job binding is fixed. A leader for the seed round cannot re-roll r_seed: it may withhold or delay progress, but commonware signs the seed message over the round encoding for notarization, finalization, and nullification, so the same absolute Round(epoch, view) yields exactly one valid seed regardless of whether its leader publishes, changes payloads, or forces nullification. If the invariant is not true for a deployment, M > 1 CIP-11 selection MUST NOT be activated with this seed schedule; governance must raise K or use a future-epoch seed. The seed domain is cowboy-runner-select-v3: with an explicit mode byte, so v3 selection cannot collide with CIP-2 §5’s cowboy-runner-select-v2: preimage. Any remaining bias is the chain-wide last-revealer property of the commonware threshold VRF: a seed-round leader that recovers the seed before publishing may withhold its own round. The target round is already fixed, so this affects the chain’s randomness for that round and cannot target one job. Because the threshold signatures are non-attributable, CIP-11 cannot turn partial seed signatures into slashable external evidence; this residual belongs to the consensus/whitepaper randomness model and should be addressed there if stronger chain randomness is required. Residual and bounds.
  • Single validator (launch): vacuous under the protocol threat model, f = 0, the lone proposer is the trusted operator (§16.2). The operator can still favor its own runners operationally; this requires governance/operations trust and provides no Byzantine fault tolerance.
  • M == 1 (None/EconomicBond): present-first can steer which eligible runner serves a job, and the submitter may know R_{S-1} before submitting. A submitter can grind mutable job bytes or job_id against that beacon to target a specific runner. The clearest abuse is griefing, such as aiming paid one-runner jobs at a victim to fill its max_concurrent_jobs. Each attempt is still an ordinary paid job, the selected runner stays bonded, and timeout and reputation rules apply. MRU washing gives no cross-submitter steering, because MRU is keyed by (submitter, job_kind). Proposer rotation limits how often one proposer can steer, but not the harm inside its own slot. The whitepaper §“MEV Reduction” does not defend against single-block proposer MEV, and committee-input steering is new CIP-11 behavior with no exemption. MRU still biases the first seat of multi-runner committees. Submitters that need stronger verification SHOULD request M > 1 verification or operate under effective Mode A (§8.3), where the proposer does not control PresenceInput. M == 1 is a latency-optimized path without committee independence.
  • M > 1 in Mode B: committee membership is over the full floor-eligible set and selected from the absolute future seed round r_seed; proposer present-set steering, submitter pre-grinding, and certifying-leader re-roll are all removed from the committee-membership path, apart from the last-revealer residual above. Presence is delivery-only.
  • Mode A: PresenceInput is consensus-verified and not proposer-set, so present-set steering does not arise; seed timing still follows §9.2.

17. Dependencies, Governance, and Optional Extensions

CIP-11 fully specifies single- and multi-validator behavior, including the reaction to reconfiguration (§5.3–§5.4, §6.2, §8, §11.5). The items below are one external dependency, governance choices and optional extensions.
  1. Consensus and execution dependencies. CIP-11 consumes (a) execution-readable consensus beacons and seeds for runner selection (§9.2), and (b) the validator-identity snapshot ValidatorSetSnapshot(epoch) (§5.4). Selection needs the parent beacon R_{S-1} for M == 1, and for M > 1 verified threshold seeds by absolute round, from notarization, finalization and nullification certificates, plus a consensus-owned advance_round. A fixed genesis set needs only ValidatorSetSnapshot(0). A changing set also needs epoch advancement, BLS threshold resharing/DKG and ValidatorSetActivated. The technical whitepaper (§“Consensus and Networking”, §“Validator Set”) and the commonware engine own consensus, epochs, beacons and the validator-set lifecycle. commonware has the mechanisms. Wiring them into Cowboy execution is a mainnet-readiness item: the parent beacon, verified seeds by absolute round, each block’s proposal round, finality information and advance_round. Because the assignment block commits consumed seeds (ConsumedSeedsV1, §9.2), only the proposer needs live certificates.
  2. Mode A enablement. Enabling Mode A needs the §5.4 snapshot and the Mode-A certificate state and instructions (§8.3). Before enabling it, governance fixes the k ↔ security ↔ fan-out operating point (§8.4), satisfies the K_HARD_MIN activation guard (§8.4/§13), and confirms the receipt anti-replay and freshness parameters (§8.3, §13). An implementation MUST ship cross-epoch replay property tests first: a stale receipt cannot extend presence_proven_until; the signed receipt preimage binds subset_epoch + validator_set_hash; the monotonic presence_anchor rejects an older-or-equal anchor; and a receipt whose (subset_epoch, validator_set_hash) does not match the active/overlap snapshot is rejected (the OVERLAP-window boundary, §5.3, is the most error-prone case).
  3. Validator–runner conflict of interest (governance). Because the launch validator is fully trusted (§16.2), governance SHOULD set expectations (disclosure, auditable push-latency, or a neutral push router) before any operator runs both a validator and runners, to deter self-favoring and MEV.
  4. MRU scope (optional extension). The coarse (submitter, job_kind) default (§9.4) is complete; a future revision MAY add a finer mru_scope (e.g. (submitter, model_id), (submitter, primary_volume_id)) per §9.5.
  5. Observability gossip (optional, non-normative). §7.5’s advisory dashboard channel MAY be standardized for cross-implementation agreement, or left to implementations.

18. Implementation Status

MRU storage, deterministic winner selection, iteration-0 weighting, and expired-record cleanup are implemented and unconditional. ACK_TIMEOUT_BLOCKS and PRESENCE_TIMEOUT_BLOCKS are implemented at the §13 default of 15. OVERLAP_BLOCKS (§5.4), Mode A (§8.3) and the reconfiguration reaction (§5.3–§5.4) are not yet implemented. Runners read GET /runner/{addr}/jobs only for the per-(job, runner) CIP-9 volume attachments of a pushed job that declares a volume, once at intake (they are not in the §12.6 frame); it is not a delivery path.
The single-validator launch needs the PresenceInput block field, the present-first dispatcher, QUIC push and MRU (§8.1). Multi-validator Mode B also consumes the §5.4 identity snapshot. Neither needs the Mode-A certificate machinery (§8.3). The single-validator launch also does not need the consensus reconfiguration dependency (§5.4).