A free, open source desktop app to test and debug your board with an AI agent and an EmbeddedCI BenchPod. Ask it in plain words: it powers the board, reads its UART console, captures logic and analog signals, emulates the sensor the firmware expects, drives voltages and flashes firmware, and shows you the logs and captures next to the conversation.
It works with the model you choose:
- A model on your own computer (Ollama, LM Studio, llama.cpp, vLLM): no account, no cost, nothing leaves your machine.
- Your own account with a provider (OpenRouter, Anthropic, OpenAI, ...): paste your key, pay the provider directly.
- A server your team runs: any endpoint that speaks the OpenAI chat-completions API.
The app has no EmbeddedCI key inside and needs no EmbeddedCI account for a pod on your network or USB.
window (webapp) ──HTTP──▶ benchpod-local ──stdio MCP──▶ embeddedci-mcp ──LAN/USB/cloud──▶ BenchPod ──▶ your board
│ agent loop
└──OpenAI API──▶ your model
benchpod-local(Go) is the app: the agent loop, the settings, the HTTP API and the page. The desktop app is a Tauri window around it; you can also run it on its own and use it in a browser tab.- The BenchPod tools are the BenchPod MCP server,
the same one the Claude and Codex plugins run. Every change to it reaches the app with no change
here. The app finds it on your
PATH, runs it with uv, or installs a private copy of uv on first start. - The agent loop (
agent/) is provider-neutral: one OpenAI-compatible client, tools from MCP, and a policy that holds the safety rules.
The panel beside the chat drives the pod by hand, without the agent:
- Console: the board's UART console. Open it (the channels and baud come from the wiring, or pick them), type a command and press Enter (LF, CRLF or no line ending; up and down arrows go through what you typed). The agent's console reads and writes show here too, in order; while the agent runs, the terminal leaves the reading to it.
- Captures: logic (14 channels), analog, or both on one time axis, at the length and rate you
pick, optionally waiting for an edge or level on an LA channel. The capture is drawn in full:
drag to zoom, double-click to reset, pick which channels to show. Decode UART, I2C or SPI from it
(the channels and baud come from the wiring) as a table and as labels on the waveform. The
agent's captures and decodes show here too. Needs embeddedci-mcp 2.13.10 or later.
Sequences: tick rows in the bus console's log and save them under a name, then run the
sequence again (each step asks the same confirmations as by hand, and a read that differs from
the recording is flagged) or export it as a pytest file for the embeddedci SDK, with an assert
per read. Sequences are kept on this computer, in
bus-sequences.jsonin the data folder. With an EmbeddedCI API key (signed in to embeddedci.com, not offline) you can also share one in your organization; shared ones are kept in your embeddedci.com account. - Generator: pick the output (3.3 V, 5 V, ±12 V or the 4-20 mA output), then drive a DC level,
play a sine, square or sawtooth, or play a waveform from your library, until Stop. Also:
- Segments: build a signal from ramps, holds and steps (durations in ms, levels in volts or mA), play it in a loop, or save it to the library.
- Fault: replay a library waveform with a window (start and width in % of it) replaced by a flatline or spike at a level you pick, or stuck at the value just before the window.
- Control loop: the FPGA loop. Each tick it reads an input, looks it up in a curve (a droop with a knee, like a solar panel's I-V, constant, rising or falling), moves the output toward it and holds it inside a clamp. The input is the ADC (closed loop), a held point you move with a slider, or a sweep. The live output and input show while it runs. Presets, the input sense chain and an output stage between the DAC and the board are in the web app only for now.
- Waveform library: kept on this computer, in the data folder's
waveformsfolder. Save the last analog capture (yours or the agent's) under a name, or import a CSV (one value per line, or time and value columns, which give the rate). Play one as recorded or scaled to fill the output; rename or delete it. - Flash: flash your board's firmware from a file (.elf, .hex or .bin) over SWD, with the OpenOCD
target, the reset line and the power rail from the wiring, and read OpenOCD's log. Then
power-cycle the board and see its boot log, and keep a target that worked in the wiring. The
file is copied into the data folder's
firmwarefolder (the last 10 stay, to flash again). OpenOCD runs on your computer: install it first (brew install open-ocdon a Mac). Below it, SPI flash chip: identify, program (erase, write, verify) and read back a 25-series SPI NOR flash on the wiring's SPI pins, optionally holding the board in reset. A read of up to 4 KB shows as hex; a longer one is saved as a file in the data folder. - Pins: the wiring profiles stored on the pod and the 14 LA pins of the one on screen, colored
by what each carries, with a red dot for a pull-up that is on and an indigo dot for a pull-down.
Click a pin to set what it is used for (a UART, I2C, SWD or SPI line, or a signal you name), what
the pod does with a signal (reads it, drives it, or both ways open drain), its pull resistor, and
its protocol's settings (the UART baud, the OpenOCD target). The I/O voltage and the power rail
sit above the pins. Make active makes a profile the pod's default: powering the board on uses
it (its I/O voltage, then its pull resistors, then the rail), and so does every tool that names
no profile. The pod never drives a board output with a push-pull driver: which way each pin goes
follows from what it is used for (firmware 3.10.4+). Firmware without stored profiles keeps the
wiring on this computer, in
wiring.jsonin the data folder. - Power: switch the internal 5 V rail or the external rail on and off, and read the voltage and the current the board draws, live, with the last minute as a chart.
Pod firmware (in Settings): the pod's firmware and gateware version, a note in the header
when a newer release is out, and an update: the latest release from GitHub, or, without internet
(offline mode), the release files you downloaded elsewhere (bench_pod_stm32.bin, its .sig,
blobs-manifest.json and the blob-*.bin files with their .sig). The pod checks the image and
its signature, restarts into it, then gets the gateware and Wi-Fi bridge images. The app runs the
bundled benchpod CLI for this (benchpod flash-self --network), over USB or your network; a
pod on embeddedci.com updates from the web app. A pod on firmware 3.x, which the app does not
drive otherwise, gets this update too (see Pod firmware 4.0).
This pod (in Settings, under Pod firmware): the pod's board, firmware, connection, network
address and USB network adapter at a glance; Wi-Fi (show the network, scan, join, forget); network
access on Ethernet and Wi-Fi (open, locked or off) and HTTPS-only; the USB network adapter on or
off; the firmware signature policy (firmware 4.0 always requires signed images: only "required"); and,
with offline mode off and benchpod login done, deregistering the pod from embeddedci.com. The
bundled benchpod CLI does the settings no BenchPod tool covers: Wi-Fi and the signature policy
as JSON over the pod's USB network adapter, network access and the USB network adapter over its
USB console. The Wi-Fi password goes to it on stdin and is never logged. The app reads the CLI's
exit codes, not its wording: 7 means the pod needs firmware 4.0, 6 that the app needs updating.
Calibration (in Settings): what the pod has stored, the ADC offset (nothing on J8), each DAC output's line from two readings of your DMM, the ADC gains measured against those outputs, and going back to the built-in values (a second click confirms it).
The controls use the same tools and the same safety settings as the agent: power, flashing and outputs ask first (unless you turned that off), the output limits apply, and every change goes to the action log. The agent reads the pod's state before it acts, so it sees what you changed.
The Sensors view (the switch at the top) makes the pod act as a sensor your firmware reads: an I2C, SPI, UART or analog part, described in a YAML file (format).
- Library: ready-made sensors (BME280, BMP280, MPU-6050, SHT4x, a GPS receiver). Open one to preview it or run it as is; duplicate it to change it.
- My sensors and Stimuli: your own definitions and stimuli (values that change over
time, with faults), with an editor that checks the file as you type and previews what the DUT
reads. They are files on this computer, in the data folder's
sensorsfolder (sensors/<kind>/<name>.yaml,stimuli/<name>.yaml), kept as you wrote them. Upload a file, or download one or all of them (a zip): downloads go to your Downloads folder. - On the pod: start a sensor on the LA channels from the wiring, after asking (an I2C start switches on the pull-ups when they are off, after asking too), change its values while the firmware runs, inject faults, read back its registers, play a stimulus.
Running sensors needs pod firmware that plays them; with older firmware the view says so and the update is in Settings. The library and the editor work without a pod and offline.
Sensor library (in Settings): the library version built into the app, the latest release,
or a specific version. Other versions download from GitHub once and are cached in the folder the
BenchPod Python SDK and CLI share (embeddedci/benchpod-sensors in your user cache folder, or
BENCHPOD_SENSOR_CACHE). Offline, or when GitHub cannot be reached, a cached version is used,
else the built-in one, with a note.
An agent driving real hardware gets limits it cannot talk its way past. They are enforced in the app, before a tool runs, never only in the prompt:
- Confirmations: power, flashing, outputs, pod settings, opening a bus (UART, CAN, I2C) and starting an emulated sensor wait for your yes (on by default). Every write to the board asks (an I2C write, SPI, CAN, GPIO); reads on a bus you opened do not (an I2C scan, a plain read or a register read: a register address of one or two bytes, then the read), so a device's "Read all" runs without a question per register. Typing in the console does not ask either.
- Limits: a ceiling for the DAC output voltage and the 4-20 mA loop current, for DC levels,
generated waveforms and replays alike (a replay scaled to fill an output counts as that output's
full range), a fault's level, and the control loop's clamp. The loop drives the output last
routed, so the app follows which one that is: a loop is refused until an output is routed
(
dac_outputwith the path and 0 V, which the Generator does for you), and moving a running loop onto an output where its clamp is above the limit is refused too. Moving a running loop's input (loop_input) asks nothing: its output stays inside the clamp it was checked with. - Caps: tool calls and model turns per message.
- Action log: every tool call, its arguments and its result, in
actions.jsonlin the data folder, with who made it: the agent, or you from the bench controls ("source": "manual").
Your model key is kept in the system keychain (macOS Keychain, Windows Credential Manager, the Secret Service on Linux), never in a file the app writes.
On a Mac, with Homebrew:
brew trust embeddedci-com/tapbrew install --cask embeddedci-com/tap/benchpod-desktopRecent versions of Homebrew ask you to trust a tap before they load anything from it.
Windows and Linux installers are on the releases page. They are not code-signed yet: on Windows, SmartScreen asks you to confirm the first start. On a Mac, the cask removes the download quarantine for you.
The app drives pods on firmware 4.0 or later: its BenchPod tools (embeddedci-mcp 4) and its
bundled benchpod CLI (0.10) speak firmware 4.0's protocol (client API 2) and refuse firmware 3.x.
A pod on firmware 3.x still takes the update, so the app offers it: Find my pod says the pod
needs firmware 4.0 and Use this pod and update it opens Pod firmware in Settings; a pod
found earlier shows "pod needs firmware 4.0 · update" at the top. The update runs the bundled
benchpod flash-self --network, over USB or your network. Keep an older app for pods you do not
update.
No account and no registration: the app talks to the pod directly.
- Find your pod: plug it in over USB-C or into your network and press Find my pod. The app looks on USB first, then on your network (mDNS); or type its address. Your board's I/O voltage (3.3 V or 1.8 V) is part of the wiring profile: set it once at the top of the Pins tab, and the pod uses it from then on, after every reboot.
- Pick a model: a local one (Ollama is preselected: start it first), or a provider such as OpenRouter, with your key. Or skip it: the bench controls work without the agent.
- Ask, or use the bench controls beside the chat. Both ask before they change power, firmware or outputs.
A pod in the cloud (embeddedci:<name>, after benchpod login) goes in Settings → Connection.
Firmware 4.0.1 and later take commands over Ethernet and Wi-Fi only from paired computers. When the
pod refuses this one (BP0081), the header shows pod not paired: click it and press Pair
this computer with the pod's USB-C cable plugged in, or Pair through embeddedci.com for a
registered pod when you are signed in. The app runs the bundled CLI's lan-clients add and
connects again. USB and embeddedci.com never need pairing.
Turn on Offline at the top of Settings and the app keeps everything on your computer and your own network:
- only a model on this computer or a server on your network (hosted providers are refused, also a custom URL that points at one);
- only pods on your network or USB: no
embeddedci:devices, no builds from embeddedci.com, and the BenchPod tools run without yourbenchpod loginsession or API key; - no downloads: the app does not install uv, and uv runs from its cache only.
The BenchPod tools must then already be installed. Either start the app once with internet
access (uv keeps its copy), or install the tools from your own package mirror so
embeddedci-mcp is on your PATH:
pipx install embeddedci-mcpTo turn offline mode on for good on a machine, so it cannot be switched off in the app, put
BENCHPOD_OFFLINE=1 in a .env file in the app's data folder (its path is at the bottom of
Settings), or set it in the environment.
Offline mode covers the app. A pod registered to embeddedci.com connects to it by itself
whenever its network reaches the internet. For a pod that should stay local, stop that with
benchpod deregister --connection <pod address> (its data stays on the account), or keep it on
a network without internet access or on USB.
Check out benchpod-ui (the chat and capture views, shared with the EmbeddedCI website) next to this repository:
git clone https://github.com/embeddedci-com/benchpod-uigit clone https://github.com/embeddedci-com/benchpod-desktopYou need Go 1.26+ and Node 22+; the desktop app also needs Rust.
cd benchpod-desktop && make run-localbuilds bin/benchpod-local and opens the app in your browser.
make desktopbuilds the desktop installer for your machine.
Copy .env.example to .env (it is git-ignored) for keys during development (make dev reads it; benchpod-local reads a .env in the working folder only with -env-file .env), for example
BENCHPOD_MODEL_API_KEY or OPENROUTER_API_KEY, and BENCHPOD_MCP_COMMAND to run the MCP
server from a checkout. A key typed in the app goes to the keychain instead.
make devruns benchpod-local and the webapp with hot reload on http://localhost:5176.
make testBPUI_SRC=/path/to/benchpod-ui/src builds and tests the webapp against another benchpod-ui
checkout (a worktree) instead of ../benchpod-ui. Refresh the built-in sensor library from a
benchpod-sensors checkout with go run ./sensors/gen -src ../benchpod-sensors -version X.Y.Z.
scripts/release.sh 0.1.0tags v0.1.0. CI runs the tests, builds every installer and makes a draft release; publishing the
draft updates the Homebrew cask (the repository needs the TAP_GITHUB_TOKEN secret).
| Path | What |
|---|---|
agent/ |
the agent loop: OpenAI-compatible model client, MCP tools, policy enforcement |
chat/ |
one conversation over HTTP and server-sent events (the protocol benchpod-ui speaks) |
policy/ |
which tools need a confirmation, the hardware limits |
providers/ |
model endpoint presets and recommended models |
local/ |
the app's backend: settings, keys, the MCP server, the HTTP API |
sensors/ |
sensor definitions (parse, convert) and the public sensor library, with its built-in copy |
cmd/benchpod-local/ |
the binary |
webapp/ |
the page |
desktop/ |
the Tauri shell |
Apache License 2.0. See LICENSE.