Remote-CX Protocol: Distributed and Remote Operations

• Remote-CX protocol is a set of mediated remote action protocols that enable non-local quantum gate operations and secure cross-boundary interactions in distributed computing systems.
• It employs shared entanglement, classical communication, and conditional corrections in quantum systems, while analogues are applied in satellite sensing, memory disaggregation, and multi-agent workspace delegation.
• Performance studies highlight that overhead from remote CX insertions and circuit depth impact fidelity, with qubit assignment strategies influencing overall system efficiency.

“Remote-CX Protocol” does not denote a single universally standardized protocol in the current arXiv literature. The expression appears most directly in distributed quantum computing, where the remote CX or remote CNOT protocol implements a logical CX gate between qubits on different quantum processing units (QPUs) by consuming shared entanglement, local gates, measurements, classical communication, and conditional Pauli corrections (Sünkel et al., 3 Feb 2026). In other domains, the label is used or interpreted analogically for protocols that mediate remote action across a protected boundary: integrated communication and remote sensing in LEO satellites, CXL-mediated remote memory and RPC, session-gated remote execution, execution-boundary integrity for LLM agents, workspace delegation across remote agents, and confidential remote computing (Xu et al., 14 Aug 2025, Wang et al., 2023, Mahar et al., 2024, Anderson, 2023, Santos-Grueiro, 7 Jul 2026, Nie et al., 24 Feb 2026, Küçük et al., 2021).

1. Scope and nomenclature

The principal technical meaning of the term is the remote CX (remote CNOT) protocol in distributed quantum computing. In that usage, the problem is exact: a CX gate must act on two computational qubits that remain physically separated across QPUs, so the protocol replaces direct two-qubit hardware interaction with a Bell-pair-assisted non-local gate construction (Sünkel et al., 3 Feb 2026).

Other papers deploy “Remote-CX” more as an interpretive umbrella than as a fixed proper name. In the LEO satellite literature, it is used to describe an integrated communication + SAR remote sensing protocol based on the ODDM waveform and a 5G-NR-compatible frame (Xu et al., 14 Aug 2025). In agentic systems, it is used for execution-boundary control, where a remote action becomes executable only after authority checks bind protected fields, sink-interpreted effects, and invocation events to the same manifest (Santos-Grueiro, 7 Jul 2026). In multi-agent collaboration, it is used for workspace delegation, where one agent temporarily exposes a real working environment—filesystem, tools, and execution context—to another agent (Nie et al., 24 Feb 2026). In memory-system research, analogous usage appears in work on CXL over Ethernet and on CXL-based shared-memory RPC (Wang et al., 2023, Mahar et al., 2024).

A recurrent misconception is to treat all of these as variants of one protocol family with a common message grammar. The literature does not support that reading. A further terminological caution arises from the supplied record for “A Secure Communication Protocol for Remote Keyless Entry System with Adaptive Adjustment of Transmission Parameters,” whose accompanying note states that the provided document is the generic IEEEtran template and “contains no information” about “Remote-CX” or any genuine RKE protocol (Guo et al., 13 Apr 2025).

2. Remote CX as a distributed quantum gate

In distributed quantum computing, the remote CX protocol implements a logical CX gate between qubits located on different QPUs without moving either qubit. The architecture distinguishes computational qubits, which represent the logical state of the monolithic circuit, from communication qubits, which are ancillas used to establish and consume entanglement across QPUs (Sünkel et al., 3 Feb 2026).

The protocol begins from a Bell pair shared between communication qubits $c_0$ and $c_1$: $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$ The standard circuit-level realization described in the literature is: prepare the Bell pair with a Hadamard on $c_0$ and a CX from $c_0$ to $c_1$; apply a local CX from the remote control qubit $\ket{\psi_0}$ to $c_0$; apply a local CX from $c_1$ to the remote target qubit $\ket{\psi_1}$; measure $c_1$0 in the computational basis; apply a Hadamard to $c_1$1, then measure it; communicate the measurement outcomes classically; and finally apply conditional Pauli corrections, represented in the circuit by a $c_1$2 on the control side and an $c_1$3 on the target side (Sünkel et al., 3 Feb 2026).

The logical effect is that the computational qubits undergo the same transformation as an ideal distributed CX: $c_1$4 with

$c_1$5

The Bell pair is consumed by the protocol, and the communication qubits are measured out. This makes remote CX a teleportation-style non-local gate primitive rather than a transport-free interaction.

The protocol’s role is foundational in distributed quantum computing because it allows multiple QPUs to behave as a larger composite machine while keeping logical qubits resident on their assigned devices. That benefit is inseparable from its overheads: ancillary entanglement, two measurements, classical signaling, conditional corrections, and a longer effective circuit than a monolithic local CX.

3. Noise, qubit assignment, and performance in distributed quantum computing

The evaluation literature models the remote CX protocol at gate level using a Qiskit-based “monolithic meta-circuit” in which the qubits of all QPUs—computational plus communication—are represented explicitly and noisy remote-CX subcircuits are inserted where cross-QPU CX gates occur (Sünkel et al., 3 Feb 2026). The noise model uses depolarizing noise on 1-qubit gates with probability $c_1$6, on 2-qubit gates with probability $c_1$7, and readout error with probability $c_1$8. Performance is reported using output-state fidelity,

$c_1$9

The principal architectural variables are the number of QPUs, the number of computational qubits per QPU, and the number of communication qubits per QPU. The study varies 2, 3, 4, or 8 QPUs, with communication-qubit counts typically 2, and in some experiments 1 or 3 (Sünkel et al., 3 Feb 2026). It compares two qubit-placement strategies. Under naive qubit assignment, logical qubits are placed on QPUs sequentially. Under graph-partitioning-based assignment, the circuit is converted to an interaction graph whose nodes are logical qubits and whose weighted edges count CX interactions, and PyMetis is used to partition that graph so as to minimize the weight of cross-partition edges.

The resulting fidelity behavior is highly circuit-dependent. For Grover (4 qubits, 2 QPUs), fidelity drops from approximately 0.87 in the monolithic case to approximately 0.70 in the distributed case, with no difference between naive and optimized mapping. For GHZ (8 qubits), fidelity degrades monotonically with QPU count: approximately 0.95 for 2 QPUs, 0.92 for 4 QPUs, and 0.85 for 8 QPUs, while graph partitioning provides little or no benefit and is even slightly worse than naive mapping in the 8-QPU case. For an 8-qubit VQC, fidelity is approximately 0.76 for 2 QPUs, 0.66 for 4 QPUs, and 0.51 for 8 QPUs; again, optimized mapping helps little for highly structured entangling patterns (Sünkel et al., 3 Feb 2026).

The strongest gains from mapping optimization appear on irregular interaction graphs. For a random 8-qubit circuit, fidelity improves from approximately 0.72 to 0.84 for 2 QPUs and from approximately 0.70 to 0.77 for 4 QPUs under graph partitioning, while the 8-QPU case becomes essentially identical. For a random 12-qubit circuit, fidelity improves from approximately 0.75 to 0.82 for 2 QPUs, from 0.71 to 0.80 for 3 QPUs, and from 0.69 to 0.76 for 4 QPUs. By contrast, varying the number of communication qubits per QPU from 1 to 3 has little effect on fidelity: for the random 12-qubit, 4-QPU case, naive mapping yields 0.69, 0.68, and 0.68, while optimized mapping yields 0.76, 0.75, and 0.76 (Sünkel et al., 3 Feb 2026).

These results fix an important point of interpretation. The dominant performance variable is typically not communication-qubit parallelism, but the count of remote CX insertions and the resulting circuit depth. Structured circuits such as GHZ and many VQCs already align reasonably well with naive sequential placement; random circuits benefit much more from graph partitioning because the protocol overhead is topologically reducible.

4. Remote-CX-like protocols in communication and memory fabrics

A distinct line of work uses the Remote-CX label or its analogue for remote interaction protocols in communication and memory systems. In LEO satellite systems, the term is used for an integrated communication + SAR remote sensing protocol built around the ODDM waveform, a 5G-NR-compatible transmission frame, shared downlink pilots, and a unified receiver that performs channel sensing, low-complexity MMSE equalization, and SAR range reconstruction. The frame is TDD, the pilot structure uses a pilot column at Doppler index $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$0 with guard bands, and the SDR prototype operates in the 28 GHz band with 245.76 MHz bandwidth, $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$1, $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$2, $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$3, a 10 ms frame, 80 slots, $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$4 CP-ODDM symbols per slot, 16-QAM, an achieved data rate of 561.74 Mbps, and SAR resolutions $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$5 m and $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$6 m (Xu et al., 14 Aug 2025).

In memory disaggregation, CXL over Ethernet lets a host processor access remote memory with native memory load/store access through Ethernet while preserving CXL-style semantics. The prototype uses one server and two FPGA boards connected by 100 Gbps networking and reports an average latency of 1.97 $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$7s for server access to remote memory, approximately 37% lower than the stated industry baseline, with latency reduced further to 415 ns for cache block and hit access on FPGA. The transport uses seven packet formats—read request, write request, read response, write response, ACK, NAK, and SACK, including combined forms—and couples retry buffers, reorder buffers, and a PFC-based congestion-control algorithm implemented via a token bucket (Wang et al., 2023).

A closely related shared-memory RPC design, RPCool, treats coherent CXL memory as the substrate for RPC. It replaces serialization with pointer passing in shared heaps whose addresses are globally coordinated, while restoring safety through seals and sandboxes. The reported no-op RTTs are 1.5 $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$8s for RPCool over CXL, 17.25 $$\ket{\Phi^+}_{c_0 c_1} = \frac{1}{\sqrt{2}}\left(\ket{00} + \ket{11}\right).$$9s for RPCool over RDMA, 2.9 $c_0$0s for eRPC, 10.9 $c_0$1s for ZhangRPC, and 5.5 ms for gRPC. The paper states that RPCool reduces round-trip latency by 1.93$c_0$2 and 7.2$c_0$3 compared with state-of-the-art RDMA and CXL-based RPC mechanisms, respectively. On the protection side, a cached sandbox enter-plus-exit costs 0.35 $c_0$4s, while seal plus standard release without an RPC costs 1.1 $c_0$5s for 1 page and 3.46 $c_0$6s for 1024 pages (Mahar et al., 2024).

Across these systems, the common pattern is not the quantum remote-CX gate itself, but a shared design principle: remote interaction is made to look local—shared waveform, shared memory, or shared address space—while explicit control mechanisms reintroduce correctness and safety at the boundary where locality has been virtualized.

5. Agentic reinterpretations: execution-boundary integrity and workspace delegation

In LLM-agent systems, Context-to-Execution Integrity (CXI) is an execution-boundary system for settings where a model reads attacker-writable context and proposes tool calls. The design requires that protected sink fields, sink-interpreted payloads, and invocation events each carry authority for the same canonical action before a proposal becomes executable. Its central mechanisms are policies that mark protected sink fields, typed releases that carry narrow validated values from writable context to specific destinations, opaque data slots that preserve evidence as data, and a deterministic gate that admits execution only after field authority, exact-effect authorization, and invocation authority all bind to the same action manifest. Evaluation covers 720 live episodes and 1,739 LLM calls in AgentDojo, plus a code-agent benchmark of 400 repository episodes, yielding 231 safe task completions and zero observed field, effect, or invocation escapes (Santos-Grueiro, 7 Jul 2026).

The protocol logic is manifest-bound and lease-bound. The action manifest

$c_0$7

binds sink, operation, task context, policy epoch, trusted snapshot, nonce, protected field assignments, and sink-interpreted payloads. Admission requires the conjunction of field validity, effect validity, and invocation validity: $c_0$8 This is a different use of “CX” from the quantum gate, but it preserves the central intuition of a remote boundary-crossing primitive whose execution is not allowed until mediated evidence aligns with a precise semantic object.

A complementary agentic reinterpretation appears in the Agent Workspace Collaboration Protocol (AWCP), which is described as “a workspace delegation protocol for deep-engagement collaboration between autonomous agents,” grounded in the Unix idea that “everything is a file.” AWCP separates a lightweight control plane from pluggable transport mechanisms. The control plane uses REST/HTTP + SSE and defines the message types INVITE, ACCEPT, START, DONE, and ERROR. The transport plane can be SSHFS, Archive, Storage, or Git. The protocol introduces a Delegator and an Executor, together with paired state machines: the DelegationStateMachine has states $c_0$9, while the AssignmentStateMachine has states $c_0$0 (Nie et al., 24 Feb 2026).

AWCP’s significance lies in replacing message-only collaboration with temporary workspace projection. The Delegator exposes a scoped directory tree; the Executor mounts or reconstructs it locally; the remote agent then works directly on files with unmodified local toolchains; and snapshots or live updates reconcile changes back to the Delegator. The live demonstrations include cross-modal dataset curation using SSHFS transport and multi-round compliance stamping using Archive transport (Nie et al., 24 Feb 2026).

6. Session mediation, confidential remote computing, and conceptual commonalities

Another strand uses Remote-CX-like semantics for authenticated remote execution contexts at the network stack. The Universal Session Protocol (USP) proposes a new TCP/IP Session Layer inserted between Transport and Application. Its core claim is that application code should not process remote data before session-layer authentication has completed. The protocol defines JSON messages initialize, connect, authenticate, token, and error. Tokens bind identity to streams, and the design goal is that, for applications requiring authentication, the application never sees user data if authentication fails (Anderson, 2023).

At a broader architectural level, Confidential Remote Computing (CRC) provides a model for secure remote computation built from hardware roots of trust, controlled software TCBs, and attestation evidence. Its participant model distinguishes Hardware Owner (HO), Data Owner (DO), and Algorithm Owner (AO), plus manufacturer and certification authority. CRC is organized across hardware, development, and attestation domains, and emphasizes TEEs, TPM-style roots of trust, property-based attestation, final-state attestation, and TCB minimization (Küçük et al., 2021). In this literature, the Remote-CX idea is neither a gate nor a message sequence alone; it is a security architecture in which remote computation must be justified by evidence about platform state, enclave state, and software composition before secrets are provisioned.

Taken together, these literatures suggest a family resemblance rather than a single protocol definition. The recurring structure is a mediated remote action that crosses a boundary—between QPUs, between satellite communication and sensing functions, between host and remote memory, between writable context and tool execution, between agents and workspaces, or between unauthenticated streams and protected applications. The principal misconception is therefore taxonomic: “Remote-CX Protocol” is best understood not as one canonical arXiv standard, but as a label whose most exact meaning is the remote CX gate protocol in distributed quantum computing and whose broader uses designate protocols that make remote interaction safe, exact, and operationally tractable by binding execution to shared state, structured evidence, or controlled delegation.