Because RemoteRF exposes radio discovery, live device API schemas, slot reservations, and IQ capture through Python, a headless JSON CLI, and a built-in Model Context Protocol (MCP) server (remoterf mcp), AI coding agents (such as Claude Code, Cursor, Gemini CLI, and Codex CLI) can participate directly in the experimental wireless research loop.
MCP & Skill Setup Reference: For one-time installation (
pip install "remoterf[mcp]",remoterf mcp install, andremoterf skill install) and the complete table of MCP tools and CLI flags, see the AI Agents & MCP User Guide.
Closed-Loop DSP & Transceiver Debugging
When developing a new waveform, synchronization block, equalizer, or neural receiver, debugging on real hardware typically requires dozens of manual edit-run-inspect cycles. With an MCP-enabled agent connected to a reserved radio, you can close that loop automatically:
-
Stage 1
Baseline on a Cabled Loopback Link
The agent queries
remoterf_list_devicesto find an online cabled loopback radio (such asPluto_09_Loopback@ucla), confirms a reservation slot with you, and runs your baseline transceiver script to verify end-to-end framing without over-the-air multipath or interference. -
Stage 2
Instrument Quantitative & Visual Diagnostics
Instead of relying on visual inspection alone, the agent logs structured telemetry to stdout or JSON on every capture—such as estimated carrier frequency offset (CFO), packet detection SNR, error vector magnitude (EVM), bit error rate (BER), and post-equalizer constellation plots saved to disk.
-
Stage 3
Iterative Hypothesis Testing on Live IQ Captures
During the active reservation window, the agent modifies DSP parameters or receiver code (e.g., Costas loop bandwidth, Gardner timing recovery gain, or pilot interpolation), re-runs the capture on the physical SDR, inspects the resulting EVM/BER and constellation image, and repeats until the link converges.
-
Stage 4
Promote to Over-the-Air & Multi-Node Links
Once the transceiver passes loopback verification, the agent switches the device handle to an over-the-air pair or MIMO array to evaluate performance under real multipath fading and hardware clock offsets.
Porting Experiments Across Heterogeneous Hardware
Wireless labs frequently combine multiple hardware families—such as low-cost ADALM-PLUTO and RTL-SDR units, wideband USRP transceivers, phase-coherent KrakenSDR arrays, and mmWave radars—each with different Python driver conventions (pyadi-iio, uhd, pyrtlsdr, or custom deployment schemas).
An MCP-connected agent can translate an experiment from one radio family to another without manual driver lookup:
- Live IDL introspection (
remoterf_device_api): Before booking a slot, the agent queriesremoterf_device_api(or readsremoterf://devices/{handle}/api) for the target handle. The server returns the exact Python import line, constructor, exposed properties, method signatures, and docstrings directly from the deployment’s Interface Description Language (IDL) schema. - Verified starter recipes (
remoterf_example_script): The agent pulls a known-goodconnect,rx_once, orrx_spectrumscript for the target handle and adapts your signal processing pipeline around the device’s native sample rate, gain range, and buffer semantics. - Custom lab instruments: If your group exposes a turntable, programmable attenuator, or custom RF front-end via a custom
DeviceSchema,remoterf_device_apiimmediately teaches the agent how to control that instrument alongside your SDRs.
Automated Sweeps & Dataset Campaigns
For large-scale measurement campaigns—such as collecting IQ datasets across carrier frequencies, transmit gains, modulation orders, or multiple geographic deployments—researchers can combine Python experiment scripts with the non-interactive JSON CLI (remoterf ... --json).
The Python example below uses the headless CLI to inspect a device’s live state, run a reproducible multi-gain EVM/SNR sweep against a reserved handle, and save a self-describing dataset manifest:
import json
import subprocess
import numpy as np
from remoterf.drivers.adalm_pluto import adi
HANDLE = "Pluto_09_Loopback@ucla"
# Query live device metadata via the headless JSON CLI
info = json.loads(
subprocess.check_output(["remoterf", "api", HANDLE, "--json"], text=True)
)
sdr = adi.Pluto(token=HANDLE)
sdr.sample_rate = int(2e6)
sdr.rx_lo = int(915e6)
sdr.tx_lo = int(915e6)
sdr.rx_buffer_size = 16384
sdr.gain_control_mode_chan0 = "manual"
sdr.rx_hardwaregain_chan0 = 20.0
# Transmit a known pilot tone / waveform
t = np.arange(4096) / sdr.sample_rate
tx_waveform = (0.5 * np.exp(1j * 2 * np.pi * 100e3 * t) * (2**14)).astype(np.complex64)
sdr.tx_cyclic_buffer = True
sdr.tx(tx_waveform)
records = []
try:
for tx_gain_db in [-30, -25, -20, -15, -10]:
sdr.tx_hardwaregain_chan0 = float(tx_gain_db)
_ = sdr.rx() # flush stale DMA buffer after gain change
iq = np.asarray(sdr.rx(), dtype=np.complex64)
spec = np.abs(np.fft.fftshift(np.fft.fft(iq))) ** 2
peak_bin = int(np.argmax(spec))
sig_pow = float(np.sum(spec[max(0, peak_bin - 2):peak_bin + 3]))
noise_pow = float(np.sum(spec) - sig_pow)
snr_db = 10.0 * np.log10(max(sig_pow, 1e-12) / max(noise_pow, 1e-12))
records.append({"tx_gain_db": tx_gain_db, "snr_db": round(snr_db, 2)})
finally:
sdr.tx_destroy_buffer()
sdr.rx_destroy_buffer()
print(json.dumps({"handle": HANDLE, "schema": info.get("device_type"), "sweep": records}, indent=2))Example Research Prompts
Once remoterf mcp and the RemoteRF agent skill are installed in your coding assistant, you can delegate end-to-end experimental tasks using natural-language prompts:
- Loopback verification & CFO estimation:
“Check which cabled loopback Plutos are free at
@ucla, ask me before reserving the current slot, and run a script that transmits a QPSK frame with a Zadoff-Chu preamble, estimates the carrier frequency offset and EVM on receive, and saves the constellation plot toqpsk_loopback.png.” - Cross-device porting (Pluto to USRP):
“Inspect the live API for
USRP_00@uclausingremoterf_device_apiand portofdm_transceiver.pyfromadi.PlutotoMultiUSRPusing timed transmit/receive bursts at 2.45 GHz and 5 MSPS.” - Multi-channel array calibration:
“Look up the exposed methods on
KrakenSDR@ucla, write a script that enables the internal calibration noise source, computes the inter-channel sample delay and phase offsets across all 5 channels relative to Channel 0, and verifies phase coherence after applying the correction.” - Multi-SDR over-the-air link budget:
“Find two online over-the-air Plutos on
@uclathat have a simultaneous free slot. After I confirm the reservations, sweep TX gain from -30 dB to -5 dB on the transmitter while logging received power spectral density and SNR on the second radio.”
Next Steps
Install remoterf[mcp], register the MCP server with your coding assistant, and browse all MCP tools and JSON CLI commands.
Stream live IQ samples between remote SDRs and PyTorch or GPU training pipelines.
Run cabled loopback, multi-SDR, and MIMO setups and collect labeled IQ datasets.