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.

2
Benchpod shows up 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
| Flag | Environment | Default | Purpose |
|---|---|---|---|
--connection | BENCHPOD_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-voltage | BENCHPOD_LA_VOLTAGE | — | LA I/O voltage (1.8 or 3.3) applied on connect |
--wiring-autosave | BENCHPOD_WIRING_AUTOSAVE | off | set_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_BASE | https://www.embeddedci.com | another embeddedci server |
--lease-wait | — | 30 | cloud: seconds connect waits for a busy pod |
--idle-timeout | — | 600 | cloud: release the lease after this many idle seconds (0 = never) |
--timeout | — | 30 | per-command pod timeout in seconds |
--transport | — | stdio | stdio or http |
--host / --port | — | 127.0.0.1 / 8000 | HTTP bind address |
--auth-token | EMBEDDEDCI_MCP_TOKEN | — | require a bearer token (mandatory off loopback) |
--allowed-host | — | — | Host header(s) to accept on a network bind |
--allow-unauthenticated | — | off | serve 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
| Tool | Purpose | Parameters |
|---|---|---|
connect | Open 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 |
disconnect | Close UART/CAN sessions and the connection, releasing a cloud lease. | none |
status | Firmware, 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_voltage | Select the LA I/O voltage to match the DUT (1.8 V needs a rev3 pod). | voltage |
lan_tls | The 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_level | Read 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_network | Read 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)
| Tool | Purpose | Parameters |
|---|---|---|
cloud_list_devices | The pods on your embeddedci.com organization and whether each is online, without connecting. | none |
Wiring profile
| Tool | Purpose | Parameters |
|---|---|---|
wiring | The 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_wiring | Replace 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_wiring | Store 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_wiring | Switch this connection to another profile stored on the pod (omit name for the pod's default). Nothing on the pod changes. | name |
set_default_wiring | Make a stored profile the pod's default: the one every connection loads when it names none. | name |
delete_wiring | Delete a stored profile. The default cannot be deleted (BP0013): make another one the default first. | name |
Power
| Tool | Purpose | Parameters |
|---|---|---|
power_on | Power 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_off | Switch the target's power rail off. | efuse, delay |
power_status | Both eFuse rails: on/off, tripped, bus voltage and current, and the pod's own draw. | none |
reset_target | Drive the DUT's reset line from the pod's reset pin. | action=pulse, pulse=0.1 |
Power profiles
| Tool | Purpose | Parameters |
|---|---|---|
measure_power | Sample supply current and voltage for a window: average, min, peak, energy and charge. | duration, efuse, rate_hz=500, points=0 |
power_profile_start | Start sampling the rail in the background while other tools run. | efuse, rate_hz=500, max_duration=60 |
power_profile_stop | Stop the running profile and return its statistics (and a trace). | points=0 |
Flash
| Tool | Purpose | Parameters |
|---|---|---|
flash | Program 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
| Tool | Purpose | Parameters |
|---|---|---|
spi_flash_info | Read the JEDEC ID and size of the SPI NOR flash on the SPI pins. | sck, mosi, miso, cs, hz=1000000, mode=0 |
spi_flash_program | Erase, 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_read | Read flash bytes to a file, or up to 4096 bytes as hex. | addr, length, file, sck, mosi, miso, cs, hz=6000000, mode=0 |
spi_transfer | One full-duplex SPI transaction with any device on the SPI pins. | tx_hex, sck, mosi, miso, cs, hz=1000000, mode=0 |
UART
| Tool | Purpose | Parameters |
|---|---|---|
capture_uart | Record 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_capture | Power-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_open | Start 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_write | Send text to the DUT through the open UART session. | text, line_ending=lf |
uart_read | Return output received since the last read, optionally waiting for a match. | until_regex, timeout=2 |
uart_close | Stop the background UART session. | none |
Emulated sensors
| Tool | Purpose | Parameters |
|---|---|---|
sensor_library | The sensor library: its sensors and stimuli (name, kind, label) and the version in use; version switches it for the other sensor tools. | version |
sensor_show | One library entry: its YAML (a starting point for your own part) and the params sensor_set takes. | name, version |
sensor_format | The definition and stimulus format reference, to write a definition from a datasheet. | version |
sensor_validate | Check 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_start | Upload 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_set | Change what a running sensor reports; a value out of range is refused with the range. | instance, values |
sensor_stimulus_load | Upload values over time (and timed faults) for the running sensors. | stimulus |
sensor_stimulus_start | Play the loaded stimulus, from t = 0 or at_s. | at_s |
sensor_stimulus_stop | Stop the stimulus; values stay where it left them. | none |
sensor_fault | Make 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_clear | End a sensor's faults. | instance |
sensor_stop | Stop one sensor, or all of them; the pod releases the pins and forgets the definition. | instance |
sensor_status | Running sensors (slot, pins, values, faults, bus counters: did the DUT talk to it?), the stimulus and the FPGA image. | none |
sensor_regs | The bytes an I2C or SPI sensor answers now. | instance, start=0, length |
sensor_capture | Capture 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
| Tool | Purpose | Parameters |
|---|---|---|
set_pull | Pull 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_status | Every LA channel's pull resistor: state (up, down or off), the directions it supports and its value. | none |
GPIO on the LA pins
| Tool | Purpose | Parameters |
|---|---|---|
la_pins | What owns each of the 14 LA channels, with GPIO mode, level and bias resistor. | none |
gpio_mode | Claim LA channels as GPIO (input, output or open drain). | la, mode=output, level |
gpio_write | Set the level of GPIO output and open-drain channels. | la, level |
gpio_read | The live level of LA channels (all 14 when la is omitted). | la |
gpio_wait | Wait until an LA channel reads a level (reached: false on timeout). | la, level=1, timeout=5 |
gpio_pulse | FPGA-timed pulses on an LA channel: width 4 us to 65.535 ms, count up to 65535. | la, width, count=1 |
gpio_release | Return channels to high-Z, watched by captures. | la |
la_dir | Tell 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
| Tool | Purpose | Parameters |
|---|---|---|
i2c_open | Make 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_transfer | Write, read, or write then read (repeated START) on the open session. Neither is a probe. | addr, write_hex, read=0 |
i2c_scan | Which addresses answer on the open session. | start=8, end=119 |
i2c_close | Release the I2C master's pins (safe when none is open). | none |
GPIO expander boards
| Tool | Purpose | Parameters |
|---|---|---|
expansion | Attach 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
| Tool | Purpose | Parameters |
|---|---|---|
analog_path | Set every analog mux and relay for a named path in one step; range sets the ADC input range too. | path, range |
dac_output | Route a DAC output and drive a calibrated DC voltage on it. | path, volts |
current_out | Hold a current on the 4-20 mA output (J9), in amps, or read its range. | current |
adc_read | One 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_range | Read 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 |
calibration | The pod's stored ADC calibration (the offset measured on the 4-20 mA input) and the fit it uses. | none |
calibrate | Measure 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_dac | Store 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_gain | Measure 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
| Tool | Purpose | Parameters |
|---|---|---|
capture_adc | Capture 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_la | Capture 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_correlated | ADC 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_la | Decode 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_timing | Edge 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
| Tool | Purpose | Parameters |
|---|---|---|
generate | Drive 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_stop | Stop any DAC output: generator, replay or control loop. | none |
replay | Loop 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_waveforms | The organization's cloud waveform library. | none |
replay_waveform | Loop 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_recording | Save the last ADC capture to the cloud waveform library. | name, full_scale_v |
Control loop
| Tool | Purpose | Parameters |
|---|---|---|
control_loop | Run 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_input | Re-target the running loop's input without re-arming. | input_code, source, step |
loop_probe | The running loop's live operating point. | none |
fpga_image | Switch the FPGA to the loop or deep_replay gateware image (~2-3 s). | image |
CAN
| Tool | Purpose | Parameters |
|---|---|---|
can_open | Bring 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_write | Queue one CAN frame (up to 64 bytes on a CAN FD bus). | can_id, data, ext=false, rtr=false, fd, brs |
can_read | Read received frames, or wait for one id. | timeout=0, can_id, max_frames=32 |
can_respond | Answer 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_status | Link state: mode, bitrate, error counters, bus-off. | none |
can_close | Clear responder rules and stop CAN. | none |
Other
| Tool | Purpose | Parameters |
|---|---|---|
la_step | Step 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 |
command | Raw firmware JSON command, for anything no tool covers. | request |
AI Vision board
| Tool | Purpose | Parameters |
|---|---|---|
vision_cloud_boards | The AI Vision boards on your embeddedci.com organization and whether each is online, with the connection to pass to vision_connect. | none |
vision_connect | Open 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_disconnect | Close the AI Vision connection and release its lease. | none |
vision_status | Version, calibration, camera lock, actuators, lease and capabilities, with warnings for what blocks the next steps. | none |
vision_look | The screen as an image, or what the camera sees; a region zooms in at full sensor resolution. | space=screen, overlay, region |
vision_ocr | All text on the screen or in a region, in reading order, with boxes. | region, zoom |
vision_find | Elements matching text, a kind (button, icon, text) or a template, best first. | text, label, template, match, region |
vision_wait_for | Wait until text appears (or, with gone, disappears); met is false on timeout. | text, timeout_s=10, gone=false, match, region |
vision_compare | How close the screen is to a stored reference screen. | reference, mask |
vision_screen_health | Black, dim, frozen, flickering or stuck pixels over a window of frames. | window_ms=1000, expect_motion=false |
vision_calibrate | Map 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_reference | Store the current screen, or a region of it as a template, as a reference. | name, kind=screen, region, overwrite=false |
vision_press | Find 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_tap | Tap 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:flashreturnsok: falsewith its logs, a UART capturematched: 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 thebenchpod:adminscope) andTransportTimeout(the pod did not answer). A dropped link is aConnectionClosedError.statusalso warns when a cloud job holds the pod or the LAN policy is locked. - Capabilities.
connectandstatusreport what the pod can do as flags, such asla_pins,capture_trigger,power_profile,nrst_pin,can,calibrate,current_out,pod_currentandanalog(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_adcreturns calibrated statistics, the dominant frequency and a min/max envelope;capture_lareturns per-channel levels, edges and frequencies. The last captures stay in the session fordecode_la,replayand saving to the waveform library. - Sessions.
uart_openbuffers the console in the background (open it beforepower_on, thenuart_read/uart_write);can_openkeeps 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






