Agentic Wireless Research

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, and remoterf 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:

  1. Stage 1

    Baseline on a Cabled Loopback Link

    The agent queries remoterf_list_devices to find an online cabled loopback radio (such as Pluto_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.

  2. 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.

  3. 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.

  4. 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 queries remoterf_device_api (or reads remoterf://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-good connect, rx_once, or rx_spectrum script 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_api immediately 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 to qpsk_loopback.png.”

  • Cross-device porting (Pluto to USRP):

    “Inspect the live API for USRP_00@ucla using remoterf_device_api and port ofdm_transceiver.py from adi.Pluto to MultiUSRP using 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 @ucla that 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