BenchPod MCP server

embeddedci-mcp is an MCP server that lets an AI agent drive a real hardware-in-the-loop bench: flash a build, power-cycle the target, watch and type into its UART, emulate the sensor it expects, probe its I2C and CAN traffic, and drive and measure analog signals. It is a thin layer over the BenchPod SDK, so what an agent finds interactively can become a pytest test. No Claude or Codex? Use the BenchPod AI agent in the web app, the free desktop app, or the live demo.

Install as a plugin

The quickest way. The plugins in embeddedci-com/benchpod-mcp run this server through uvx and ask for the pod's address, the board's I/O voltage and an optional API key. All you need is a BenchPod reachable over Ethernet (recommended) or Wi-Fi, its USB-C cable to this computer, or embeddedci.com; the plugins install everything else on first start (see the FAQ).

No terminal and no claude command needed.

1

Open Settings → Plugins, click Add and add a marketplace. Choose Add from a repository and enter embeddedci-com/benchpod-mcp.

Claude app Add marketplace dialog with Browse Anthropic sources and Add from a repository

2

Benchpod shows up under From marketplaces you added.

Claude app Settings, Plugins page listing Benchpod under From marketplaces you added

The plugin works in the Code tab. Ask the agent to connect to your pod ("connect to the BenchPod at 192.168.1.213", or "find my BenchPod on the network") and it sets the board's I/O voltage before it uses the pins.

Set up your client by hand

The configs below run the server with uvx, so they need uv on your PATH (how to install it). The Claude app extension brings its own.

claude mcp add benchpod \
  -e BENCHPOD_CONNECTION=192.168.1.213 -e BENCHPOD_LA_VOLTAGE=3.3 \
  -- uvx embeddedci-mcp

BENCHPOD_LA_VOLTAGE must match the target's I/O voltage (1.8 for a 1V8 board). The pod refuses flashing, UART, logic capture, pull resistors and sensor emulation until it is set. Without it the agent is told to call set_la_voltage first.

A pod in the cloud

"env": {
  "BENCHPOD_CONNECTION": "embeddedci:my-bench",
  "BENCHPOD_API_KEY": "eci_…",
  "BENCHPOD_LA_VOLTAGE": "3.3"
}

Or skip the API key: after benchpod login the server reuses that session for cloud_list_devices and connect("embeddedci:<name>"). BENCHPOD_API_KEY wins when set, and inside GitHub Actions the SDK uses OIDC instead. cloud_list_devices lists the pods on your account and which are online without connecting to one; pass a result's connection to connect.

A cloud pod is shared, so connect takes an exclusive lease. It is released by disconnect, or after the idle timeout (10 minutes by default); the next tool call reconnects transparently, so an idle chat never blocks CI on that pod.

The saved connection

connect picks its connection from its connection argument, then --connection, then BENCHPOD_CONNECTION, then the default connection the CLI saved (benchpod set-connection or benchpod discover --save, in ~/.config/benchpod-cli/config.json), then mDNS discovery of the one pod on the LAN. So a pod you set up with the CLI needs no MCP configuration. Needs embeddedci 2.10 or newer.

The wiring profile

The server uses the profiles stored on the pod, the same ones the SDK, the CLI and the web app see, over the LAN, USB and the cloud. connect loads the pod's default profile, or the one named by its wiring_profile argument. A local file (BENCHPOD_WIRING) wins over both. Firmware older than 3.10.8 keeps no profiles on the pod; then the profile on embeddedci.com is used, as before.

Nothing is wired by default: a pin, I/O voltage or power rail the profile does not set is undefined, and a tool that needs it says which argument to pass. The agent then asks you which LA channel a signal is on; it never guesses a pin.

set_wiring changes the profile for this connection only. Its result lists what is not stored yet in unsaved_changes, with a hint, and that is lost on disconnect. Saving is always a separate step: save_wiring (or set_wiring(save=true)) stores it on the pod, under the loaded profile's name or a new one for another board. Saving never changes which profile is the default; set_default_wiring does. A server started with --wiring-autosave (or BENCHPOD_WIRING_AUTOSAVE=1) stores every set_wiring change, except a change of the I/O voltage, the power rail or the SWD target: those always need save_wiring.

power_on applies the profile first: its I/O voltage, its pull resistors (pulls), then its rail. The I/O voltage is set at DUT power-on, never when the pod boots. Refusals carry a stable code such as BP0009 with the fix (see Error codes). Needs embeddedci-mcp 3.0 and firmware 3.10.8 or newer.

connect and set_wiring also send the profile's pin directions to the pod (firmware 3.10.4 or newer), so it never drives against a board output; wiring shows each channel's dut_dir (see Pin directions).

Options

FlagEnvironmentDefaultPurpose
--connectionBENCHPOD_CONNECTION—host[:port] (Ethernet or Wi-Fi), usb or usb:<name> (the pod's USB-C cable: the full API over its USB network adapter on firmware 3.9.0+), a serial device (console only), discover, or embeddedci:<name>
--la-voltageBENCHPOD_LA_VOLTAGE—LA I/O voltage (1.8 or 3.3) applied on connect
--wiring-autosaveBENCHPOD_WIRING_AUTOSAVEoffset_wiring also stores the profile on the pod, except a change of the I/O voltage, the power rail or the SWD target (the agent calls save_wiring for those)
—BENCHPOD_API_KEY—cloud pods and the waveform library (without it, the benchpod login session)
—BENCHPOD_API_BASEhttps://www.embeddedci.comanother embeddedci server
--lease-wait—30cloud: seconds connect waits for a busy pod
--idle-timeout—600cloud: release the lease after this many idle seconds (0 = never)
--timeout—30per-command pod timeout in seconds
--transport—stdiostdio or http
--host / --port—127.0.0.1 / 8000HTTP bind address
--auth-tokenEMBEDDEDCI_MCP_TOKEN—require a bearer token (mandatory off loopback)
--allowed-host——Host header(s) to accept on a network bind
--allow-unauthenticated—offserve a network address without a token (isolated networks only)

Serving a bench over HTTP

Run the server next to the pod, then point clients at it:

export EMBEDDEDCI_MCP_TOKEN=$(openssl rand -hex 32)
embeddedci-mcp --transport http --host 0.0.0.0 --connection 192.168.1.213 --la-voltage 3.3
claude mcp add --transport http benchpod http://bench-host:8000/mcp \
  --header "Authorization: Bearer $EMBEDDEDCI_MCP_TOKEN"

The server drives real hardware, so it refuses a non-loopback bind without a token. All HTTP clients share one pod connection and their tool calls are serialized.

Tools

Parameters in bold are required; the others are optional and show their default when they have one (no default means from the wiring profile, keep the current setting, or not used). Units are volts, amps, seconds and hertz. LA channel arguments take a number (1-14) or a name from the wiring profile. Each tool's input schema carries the full description, ranges and enums.

Connection

ToolPurposeParameters
connectOpen a connection (closing any previous one) and report status and capabilities: a host over Ethernet or Wi-Fi, usb for a pod on this computer's USB-C cable (its USB network adapter, the full API on firmware 3.9.0+), or embeddedci:<name>.connection, la_voltage, lease_wait=30, wiring_profile
disconnectClose UART/CAN sessions and the connection, releasing a cloud lease.none
statusFirmware, capabilities, LA voltage, open sessions and warnings (works when not connected), and the pod's Ethernet and Wi-Fi MACs (`eth_mac`, `wifi_mac`) for a network that registers devices first.none
set_la_voltageSelect the LA I/O voltage to match the DUT (1.8 V needs a rev3 pod).voltage
lan_tlsThe pod's API over TLS on port 8443 (firmware 3.9.3+): the certificate's SHA-256 that clients pin, and the HTTPS-only setting (plaintext 8080 off on Ethernet and Wi-Fi). connect uses TLS by itself when the pod has it.https_only, regenerate
log_levelRead or set how much the pod prints on its USB console (firmware newer than 3.10.12): error, warn, info (the default) or debug, which also prints every command trace and the reconnect retry detail. Stored on the pod.level
usb_networkRead the pod's USB network setting (firmware 3.9.0+), or turn the adapter off over the USB link. Turning it back on is benchpod usb-network on on the USB console.set

Cloud (embeddedci.com)

ToolPurposeParameters
cloud_list_devicesThe pods on your embeddedci.com organization and whether each is online, without connecting.none

Wiring profile

ToolPurposeParameters
wiringThe profile this connection uses: which DUT signal is on which LA channel, the I/O voltage, the power rail, UART baud and SWD target. Also the profiles stored on the pod, its default, unsaved_changes with a hint, and header_map: the profile on the pod's real I/O header as text (board_header says which header), to show how to wire the board.none
set_wiringReplace the wiring profile for this connection only (schema version 2: what it leaves out is undefined). save=true, or a server started with --wiring-autosave, also stores it on the pod.profile, save=false
save_wiringStore a profile on the pod, where the web app, CI and every other connection see it. Default name: the profile this connection loaded, else the pod's default. Never changes the default. Refused with BP0009 when someone else saved that profile meanwhile.name, profile
load_wiringSwitch this connection to another profile stored on the pod (omit name for the pod's default). Nothing on the pod changes.name
set_default_wiringMake a stored profile the pod's default: the one every connection loads when it names none.name
delete_wiringDelete a stored profile. The default cannot be deleted (BP0013): make another one the default first.name

Power

ToolPurposeParameters
power_onPower the board on with its wiring profile applied first: the profile's I/O voltage, its pull resistors, then its rail (optionally scheduled pod-side). The pod records the profile, and the result names it. Never changes the I/O voltage under a powered board.efuse, delay, wiring_profile
power_offSwitch the target's power rail off.efuse, delay
power_statusBoth eFuse rails: on/off, tripped, bus voltage and current, and the pod's own draw.none
reset_targetDrive the DUT's reset line from the pod's reset pin.action=pulse, pulse=0.1

Power profiles

ToolPurposeParameters
measure_powerSample supply current and voltage for a window: average, min, peak, energy and charge.duration, efuse, rate_hz=500, points=0
power_profile_startStart sampling the rail in the background while other tools run.efuse, rate_hz=500, max_duration=60
power_profile_stopStop the running profile and return its statistics (and a trace).points=0

Flash

ToolPurposeParameters
flashProgram the DUT over SWD through the pod's CMSIS-DAP probe: a local file (OpenOCD runs next to the server), or a build uploaded to embeddedci.com (build id or latest, repo, ref). On an embeddedci:<pod> connection embeddedci.com runs OpenOCD for an uploaded build; on LAN/USB it is downloaded and flashed next to the server. The result's artifact says which build was flashed. With target esp32 (or esp32s3, esp32c3, ...) the pod flashes an ESP32-family target through its UART ROM bootloader instead: file is a .bin (at load_address) or an ESP-IDF flasher_args.json, TXD0/RXD0 on rx/tx, IO0 on boot, EN on the reset pin (nreset).swclk, swdio, target, file, nreset, load_address, target_power, verify=true, reset=true, connect_under_reset, extra_configs, extra_args, timeout=300, connect_attempts=5, build, repo, ref, artifact, server_side, rx, tx, boot

SPI flash and SPI devices

ToolPurposeParameters
spi_flash_infoRead the JEDEC ID and size of the SPI NOR flash on the SPI pins.sck, mosi, miso, cs, hz=1000000, mode=0
spi_flash_programErase, write and verify an image in the SPI NOR flash.file, addr=0, erase=true, verify=true, hold_reset=false, sck, mosi, miso, cs, hz=6000000, mode=0
spi_flash_readRead flash bytes to a file, or up to 4096 bytes as hex.addr, length, file, sck, mosi, miso, cs, hz=6000000, mode=0
spi_transferOne full-duplex SPI transaction with any device on the SPI pins.tx_hex, sck, mosi, miso, cs, hz=1000000, mode=0

UART

ToolPurposeParameters
capture_uartRecord the DUT's UART for a window, or until a regex matches.duration, rx, tx, baud, until_regex, parity=none, stop_bits=1
power_cycle_and_capturePower-cycle the target and capture UART across the boot.rx, tx, efuse, delay=1, duration=4, baud, until_regex, off_settle=0.3, parity=none, stop_bits=1
uart_openStart buffering the DUT's UART in the background. 8N1 unless parity (none, even, odd) or stop_bits (1, 2) say otherwise; anything else needs firmware 3.10.8+.rx, tx, baud, parity=none, stop_bits=1
uart_writeSend text to the DUT through the open UART session.text, line_ending=lf
uart_readReturn output received since the last read, optionally waiting for a match.until_regex, timeout=2
uart_closeStop the background UART session.none

Emulated sensors

ToolPurposeParameters
sensor_libraryThe sensor library: its sensors and stimuli (name, kind, label) and the version in use; version switches it for the other sensor tools.version
sensor_showOne library entry: its YAML (a starting point for your own part) and the params sensor_set takes.name, version
sensor_formatThe definition and stimulus format reference, to write a definition from a datasheet.version
sensor_validateCheck a definition (a library name, YAML or JSON text, an object or a path): the header, then a dry-run compile on the pod.definition
sensor_startUpload a definition and start it on pins (set the LA voltage and, for I2C, the pull-ups first); returns its params. I2C, SPI and UART sensors load the emulation FPGA image.definition, instance, pins, address, baud, values
sensor_setChange what a running sensor reports; a value out of range is refused with the range.instance, values
sensor_stimulus_loadUpload values over time (and timed faults) for the running sensors.stimulus
sensor_stimulus_startPlay the loaded stimulus, from t = 0 or at_s.at_s
sensor_stimulus_stopStop the stimulus; values stay where it left them.none
sensor_faultMake a sensor misbehave now: stuck, offset, gain, no_response, corrupt, bus_stuck, garbage, drop, baud_error, open, short.instance, type, duration_s, param, value, at, mask, rate_hz
sensor_fault_clearEnd a sensor's faults.instance
sensor_stopStop one sensor, or all of them; the pod releases the pins and forgets the definition.instance
sensor_statusRunning sensors (slot, pins, values, faults, bus counters: did the DUT talk to it?), the stimulus and the FPGA image.none
sensor_regsThe bytes an I2C or SPI sensor answers now.instance, start=0, length
sensor_captureCapture an I2C sensor's bus and decode it into a transaction trace (capture_la for SPI and UART sensors).instance, samples=4096, address, register

Pull resistors

ToolPurposeParameters
set_pullPull LA channels up or down, or switch their pull resistor off; the pod picks the resistor. Today LA1-LA6 pull up, LA7/LA8 down, LA9-LA14 have none; another direction is refused (BP0024, BP0023). enabled is the older on/off form.las, pull, enabled
pull_statusEvery LA channel's pull resistor: state (up, down or off), the directions it supports and its value.none

GPIO on the LA pins

ToolPurposeParameters
la_pinsWhat owns each of the 14 LA channels, with GPIO mode, level and bias resistor.none
gpio_modeClaim LA channels as GPIO (input, output or open drain).la, mode=output, level
gpio_writeSet the level of GPIO output and open-drain channels.la, level
gpio_readThe live level of LA channels (all 14 when la is omitted).la
gpio_waitWait until an LA channel reads a level (reached: false on timeout).la, level=1, timeout=5
gpio_pulseFPGA-timed pulses on an LA channel: width 4 us to 65.535 ms, count up to 65535.la, width, count=1
gpio_releaseReturn channels to high-Z, watched by captures.la
la_dirTell the pod which way each pin's DUT signal goes (dut_output, dut_input, bidir), so it never drives against a board output (firmware 3.10.4+). Omit la and dir to list every pin; from_wiring sends the wiring profile's directions again.la, dir, from_wiring=false

I2C master

ToolPurposeParameters
i2c_openMake the pod an I2C master on two LA pins (gateware v55+), replacing any open session. Pins default to the profile's i2c_sda and i2c_scl.sda, scl, hz=100000, pullups=pod
i2c_transferWrite, read, or write then read (repeated START) on the open session. Neither is a probe.addr, write_hex, read=0
i2c_scanWhich addresses answer on the open session.start=8, end=119
i2c_closeRelease the I2C master's pins (safe when none is open).none

GPIO expander boards

ToolPurposeParameters
expansionAttach an I2C or SPI GPIO expander board on LA pins, report it, or detach it. Its pins are EXT1..EXTn (or the names you give) and work in gpio_mode, gpio_write, gpio_read, gpio_wait and gpio_release. See GPIO expander boards under Supported hardware.chip, detach=false, addr, sda, scl, spi, load, count, hz, pullups, names

Analog

ToolPurposeParameters
analog_pathSet every analog mux and relay for a named path in one step; range sets the ADC input range too.path, range
dac_outputRoute a DAC output and drive a calibrated DC voltage on it.path, volts
current_outHold a current on the 4-20 mA output (J9), in amps, or read its range.current
adc_readOne calibrated reading: front SMA, DAC loopbacks or the 4-20 mA input (J8); reports the ADC range, its full scale and overrange.source=ext, range
adc_rangeRead or switch the ADC input range: normal ±32.8 V, or low ±5.46 V at 6x the resolution (analog module v3r4+, firmware 3.9.5+; 1.82 MΩ input, 1x leads only). test=true self-tests it through the cal1 loopback.range, test=false
calibrationThe pod's stored ADC calibration (the offset measured on the 4-20 mA input) and the fit it uses.none
calibrateMeasure and store the ADC offset on the 4-20 mA input (J8 open), or clear it. Firmware 3.9.3 and later apply it to every analog input.source=current_in, clear=false, clear_part
calibrate_dacStore this pod's own line for a DAC output from two DMM readings of set points driven with dac_output (firmware 3.9.4+).path, code1, volts1, code2, volts2
calibrate_adc_gainMeasure an ADC source's gain (cal1, cal2, ext) through a loopback against a DMM-calibrated output (firmware 3.9.4+); range=low measures the ADC low range's gain through cal1 (firmware 3.9.5+).source, range=normal

Capture and decode

ToolPurposeParameters
capture_adcCapture the ADC: calibrated statistics, dominant frequency and a min/max envelope; clipped_samples counts samples past the range's full scale. oversample converts at 400 kS/s and averages down to sample_rate_hz for lower noise and a smaller step at 0 V, about 5 s at most.samples=4096, sample_rate_hz, source, points=200, trigger_la, trigger_edge=rising, trigger_timeout=10, range, oversample=false
capture_laCapture all 14 LA channels: levels, edge count, first edge and frequency per channel. Up to 12 MS/s, or 48 MS/s on gateware v50 and later (the reply says the rate it ran at; truncated says why a fast capture stopped early). trigger_pre_samples also keeps samples from before the trigger. send runs one I2C, SPI or GPIO transaction right after the capture arms (gateware v55+).samples=4096, sample_rate_hz, stop_dac_after, trigger_la, trigger_edge=rising, trigger_timeout=10, trigger_pre_samples=0, send
capture_correlatedADC and LA from one hardware trigger, on one timebase.adc_samples=4096, adc_sample_rate_hz, la_samples=4096, la_sample_rate_hz, stop_dac_after, points=200, trigger_la, trigger_edge=rising, trigger_timeout=10, source
decode_laDecode I2C, UART or SPI from the last LA capture (or a new one).protocol, sda, scl, rx, baud, sclk, mosi, miso, cs, mode=0, capture=last, samples=16384, sample_rate_hz=1000000, max_items=200
la_timingEdge timestamps, pulse widths, frequency, duty cycle and channel-to-channel delay from the last capture.la, edge=rising, to_la, to_edge=rising, after=0, max_edges=100

DAC

ToolPurposeParameters
generateDrive a sine, square or sawtooth on a DAC output (volts, or amps on current_out).waveform, freq_hz, amplitude, offset, dac_path=3v3, duration, sample_rate_hz, on_capture=false, route=true
dac_stopStop any DAC output: generator, replay or control loop.none
replayLoop your own samples, or the last ADC capture, out of the DAC.volts, from_last_capture=false, dac_path=3v3, mapping=faithful, sample_rate_hz, fault, on_capture=false, route=true, switch_image=true
list_waveformsThe organization's cloud waveform library.none
replay_waveformLoop a cloud-library waveform out of the DAC.waveform_id, dac_path, mapping=faithful, sample_rate_hz, window_start=0, window_len=0, target_samples=0, fault, on_capture=false, switch_image=true
save_capture_as_recordingSave the last ADC capture to the cloud waveform library.name, full_scale_v

Control loop

ToolPurposeParameters
control_loopRun a tabulated transfer function in the FPGA (for example a solar panel I-V curve).curve, voc_code, sharpness=4, points=256, k=8192, vmin=0, vmax=65535, tick_div=64, source, input_code=0, step=0, input_map, switch_image=true
loop_inputRe-target the running loop's input without re-arming.input_code, source, step
loop_probeThe running loop's live operating point.none
fpga_imageSwitch the FPGA to the loop or deep_replay gateware image (~2-3 s).image

CAN

ToolPurposeParameters
can_openBring up the pod's CAN interface (normal, loopback or listen-only); data_bitrate makes it CAN FD (firmware 3.10.2+).bitrate=500000, mode=normal, term=false, data_bitrate
can_writeQueue one CAN frame (up to 64 bytes on a CAN FD bus).can_id, data, ext=false, rtr=false, fd, brs
can_readRead received frames, or wait for one id.timeout=0, can_id, max_frames=32
can_respondAnswer a CAN id from the pod firmware (ECU simulation), or clear all rules.match_id, reply_id, reply_data, match_ext=false, reply_ext=false, reply_fd, reply_brs, clear=false
can_statusLink state: mode, bitrate, error counters, bus-off.none
can_closeClear responder rules and stop CAN.none

Other

ToolPurposeParameters
la_stepStep pulses for step/dir motor drivers: delay is half the step period (4 us to 65.535 ms), steps up to 65535.la, steps, delay, dir_la, direction=0
commandRaw firmware JSON command, for anything no tool covers.request

AI Vision board

ToolPurposeParameters
vision_cloud_boardsThe AI Vision boards on your embeddedci.com organization and whether each is online, with the connection to pass to vision_connect.none
vision_connectOpen the AI Vision connection (closing a previous one) and report the board's status: a LAN address, discover (mDNS), or embeddedci:<name> over embeddedci.com. lease_as takes the board's lease (over embeddedci.com, the device lease).connection, token, lease_as
vision_disconnectClose the AI Vision connection and release its lease.none
vision_statusVersion, calibration, camera lock, actuators, lease and capabilities, with warnings for what blocks the next steps.none
vision_lookThe screen as an image, or what the camera sees; a region zooms in at full sensor resolution.space=screen, overlay, region
vision_ocrAll text on the screen or in a region, in reading order, with boxes.region, zoom
vision_findElements matching text, a kind (button, icon, text) or a template, best first.text, label, template, match, region
vision_wait_forWait until text appears (or, with gone, disappears); met is false on timeout.text, timeout_s=10, gone=false, match, region
vision_compareHow close the screen is to a stored reference screen.reference, mask
vision_screen_healthBlack, dim, frozen, flickering or stuck pixels over a window of frames.window_ms=1000, expect_motion=false
vision_calibrateMap camera pixels to screen pixels (four corners and the screen size, or method auto/markers); later boxes and taps are in screen pixels.corners, screen_size, method
vision_add_referenceStore the current screen, or a region of it as a template, as a reference.name, kind=screen, region, overwrite=false
vision_pressFind an element, tap its center with the actuator, and optionally wait for verify_text. Fails with the visible text when it is not there.text, verify_text, verify_timeout_s=5, match, actuator
vision_tapTap a point in screen pixels (hold_ms for a long press).x, y, hold_ms=0, actuator

Two resources are also exposed: benchpod://wiring (the connected pod's effective wiring profile: which role or named signal is on each LA channel) and benchpod://help (the server instructions). The wiring tool returns the same profile and set_wiring changes it for the connection; it is the profile stored on the pod that the web app's Pins pane edits and the SDK reads as bp.wiring.

For drawing captures in an app (the BenchPod desktop app's capture view), three more resources give the last capture in full, as JSON (embeddedci-mcp 2.13.10 and later): benchpod://capture/la (the last capture_la or capture_correlated as run-length edges, a sample index and the 14-channel word, with the sample rate), benchpod://capture/adc (the last capture_adc or capture_correlated: samples in volts, or mA for current_in, with the unit and sample rate) and benchpod://capture/decode (the last decode_la: I2C transactions with timed segments, or UART and SPI frames with their start and end times). Each carries a seq that numbers the captures and is {"seq": 0} before the first one; correlated says the logic and analog captures share one time axis. They can be megabytes, so an agent reads the capture tools' summaries, la_timing and decode_la instead.

How it behaves

  • Instructions. The server sends usage instructions when a client connects (session start, typical flows, units), so the agent knows to connect and set the LA voltage before anything else.
  • Typed, structured results. Every tool has an input schema with enums and ranges (paths, sources, LA channels 1-14, eFuse 1/2) and an output schema. Units are volts, seconds and hertz.
  • Errors. A tool that cannot do what was asked fails with an error that names the cause, such as FirmwareError: uart_proxy_start: la voltage not set; call set_la_voltage first with the DUT's I/O voltage (1.8 or 3.3). A completed operation with a negative outcome is a normal result: flash returns ok: false with its logs, a UART capture matched: false.
  • Refusals. When the pod or the server refuses a command, the error names the kind and ends with a one-line hint: PodLockedError (the pod's LAN policy keeps the command for the cloud or USB), PodLeasedError (a cloud job holds the pod, with who and for how long), PodBusyError (a capture or upload is running), PermissionDeniedError (the credential lacks the right, for example an API key without the benchpod:admin scope) and TransportTimeout (the pod did not answer). A dropped link is a ConnectionClosedError. status also warns when a cloud job holds the pod or the LAN policy is locked.
  • Capabilities. connect and status report what the pod can do as flags, such as la_pins, capture_trigger, power_profile, nrst_pin, can, calibrate, current_out, pod_current and analog (false on the digital-only board), plus its policy and cloud settings (dac_limits, flash_kb, ota_sig, sig_policy, lan_policy, tunnel_max_tier, lease_state, cloud_ca, cloud_proxy), so an agent can check before it calls a tool.
  • Agent-sized captures. capture_adc returns calibrated statistics, the dominant frequency and a min/max envelope; capture_la returns per-channel levels, edges and frequencies. The last captures stay in the session for decode_la, replay and saving to the waveform library.
  • Sessions. uart_open buffers the console in the background (open it before power_on, then uart_read / uart_write); can_open keeps a CAN bus open across calls.
  • Non-blocking. Long operations such as a flash run in the background, send progress, and never interleave commands with another call.
  • Annotations. Read-only tools are marked so clients can auto-approve them; tools that power, flash or drive voltages are marked destructive.

Example agent flow

connect(wiring_profile="process-node-stm32")   # BENCHPOD_CONNECTION; your board's profile on the pod
wiring()                                   # which DUT signal is on which LA channel (here UART RX LA3, TX LA4)
flash(file="build/app.elf")                # SWD pins, reset line, target and rail from the profile
power_cycle_and_capture(delay=1.0, duration=5.0, until_regex="APP_OK")   # UART pins from the profile
set_pull(las=[1, 2], pull="up")            # I2C SCL LA1, SDA LA2 on this bench
sensor_start(definition="bmp280", values={"temperature_c": 22.5})   # SDA/SCL from the wiring profile
power_cycle_and_capture(delay=1.0, duration=5.0)
sensor_capture(instance="bmp280", address=0x76, register=0xD0)   # did the firmware read the chip id?

FAQ

Do I need to install uv or Python?

Not for the plugins. The Claude Code and Codex plugins (1.0.8 and later) use your uv if you have one, and otherwise download a private copy on first start, which also fetches Python. Setting up a client by hand (claude mcp add, codex mcp add, a JSON or TOML config) runs uvx, so that needs uv on your PATH. Alternatively, pip install embeddedci-mcp (Python 3.10+) and run embeddedci-mcp as the command.

brew install uv
# or: curl -LsSf https://astral.sh/uv/install.sh | sh

Codex says “no BenchPod MCP tools are exposed”

The plugin is installed but its server didn't start. The first start downloads uv and the server, so give it a minute, then quit Codex completely and reopen it. Plugin versions before 1.0.8 need uv installed already: update or reinstall the BenchPod plugin in Codex, or install uv (above).

“command not found: claude” or “codex”

The Claude and Codex desktop apps don't add a command-line tool. Use the app steps above, which need no terminal, or install the CLI from the tabs in its section.

What does flashing need?

The flash tool drives OpenOCD on the machine running the server, and reads the firmware file from that machine too. It needs the cmsis_dap_tcp backend, which only exists in builds newer than 0.12.0; the stock packages lack it. Nothing else needs OpenOCD.

# Homebrew's stable open-ocd is 0.12.0, so build it from HEAD
brew install --HEAD open-ocd