UARTBuddy

The serial toolkit for the AI agent era.

Shared serial access. Queryable logs. Archived firmware versions. Camera context. One MCP connection.

English | 简体中文

Website · Download · Get started · Connect your agent · Usage guide

Your agent should be able to debug real hardware, not stop at writing code. UARTBuddy brings serial access, logs, firmware versions, and cameras into one workspace. You watch in the desktop UI; your agent operates through MCP. Both share the connections and the record of what happened.

From one development board to a multi-device bench, stop handing over ports, copying logs, and hunting for old binaries.

Five core benefits

1. Stop competing for ports. Make agent I/O visible and traceable.

UARTBuddy owns the serial connection so you and your agent can share it. Keep your monitor open and see what the agent actually did to the device.

• Shared access: watch in the UI while the agent reads and writes through MCP, with multiple devices connected at once.
• Visible operations: serial records carry timestamps and sources; MCP calls leave a trace, so commands and responses can be reviewed.
• Coordinated flashing: temporarily release only the target port while other devices stay online.

2. Persist every captured log. Let your agent query it anytime.

Debugging context should not disappear with a terminal window or depend on repeated copy-paste. UARTBuddy saves captured serial RX/TX, system, MCP, and flash events in a local database for both you and your agent to revisit.

• Keep the history: review past sessions to recover commands, responses, and errors.
• Read selectively: query by device, event type, session, and event cursor to retrieve just the context needed.
• Keep following: read the history, then wait for new output to continue the investigation.

3. Flash and archive. Turn firmware history into a version library.

Keep more than a .bin that the next build will overwrite. Each flash retains firmware copies, address mappings, the detected or supplied version, and execution results—so you know what was flashed, where it came from, and how to flash it again.

• Retain past versions: reflash archived copies to a compatible device even after the original build directory is gone.
• Keep partitions together: display multiple images as one package with per-partition details, and reuse their address mappings when reflashing.
• Link flash records automatically: group execution history under its firmware package without duplicating entries for repeated flashes.
• Connect Git to firmware: supply commit_id and note when flashing, then view source revisions, firmware versions, and test notes together in the library.

Association scope: flash records are automatically linked to firmware packages. Runtime serial logs are currently traceable by device, session, and time—not directly tagged with firmware versions. Git commits are caller-supplied, not scanned from the repository. Reflashing does not restore a device-data snapshot.

Explore firmware version management →

4. Add camera context. Connect debugging to the physical result.

A log says “success”—but did anything change on the bench? Camera integration brings evidence beyond the serial output into the debugging workflow.

• Observe real feedback: preview, photograph, and record displays, indicators, and mechanisms with a USB camera.
• Let the agent request captures: use the same MCP service; image-capable clients with file access can inspect the results.
• Review the evidence together: compare commands, device logs, firmware provenance, and scene captures in the same investigation.

View workspace screenshots →

5. Configure one MCP connection. Access the whole toolkit.

Copy UARTBuddy's MCP endpoint into a client such as Codex or Claude Code. Serial I/O, historical logs, flashing, firmware reuse, and cameras are available through one service—no separate tool-service setup for each capability.

Connect your hardware, start by asking the agent to read logs, then authorize writes, flashes, or captures when ready. Keep UARTBuddy running and prepare hardware permissions, vendor flashing tools, and ffmpeg for video.

Give your agent a complete debugging task

Confirm my controller and read its recent logs. Flash all images using this build's address map, record the Git commit and test note, wait for the result, then check startup output. If a camera is available, capture a photo so I can check the indicator. Summarize the version, execution result, and evidence.

Follow the same operation in the UI, inspect the archived version and flash history in the firmware library, and later reflash that package to an explicitly selected compatible device. Your existing toolchain still compiles the firmware; you choose targets and permissions.

See the multi-image flashing example →

Get started

1. Open UARTBuddy. Download a release or build from source.
2. Connect a board. Click +, select its serial endpoint, set the parameters, and connect. Close any other monitor holding that port.
3. Bring your agent in. Open MCP, click Copy beside the address, and add it to your agent's MCP configuration.
4. Try a read first. Ask the agent to list devices and read output from the board you select. Enable writes or flashing when you are ready.

The local MCP endpoint is:

http://127.0.0.1:8765/mcp

Codex setup · Claude Code setup · Full setup guide

Fits your existing toolchain

• macOS and Windows: Apple Silicon macOS packages and x86-64 Windows packages, with English and Simplified Chinese UI.
• Your flashing tools: built-in discovery for esptool, espflash, and stm32flash, plus custom providers. Multi-image flashing requires an address-map-capable provider such as the built-in esptool definition.
• Start with serial: no flasher or camera dependency is needed for serial monitoring.
• Local storage: logs, firmware archives, and recordings stay on your machine. What your connected AI client sends to its model provider depends on that client's configuration.

Current source version: 1.0.0. Published releases may lag the features described here. macOS packages are ad-hoc signed and not notarized; Windows packages are unsigned. Keep the unauthenticated MCP service local and configure operation approvals in your client.

Go deeper

• Agent setup and 30 MCP tools
• Firmware version management, partition layouts, and source annotations
• Data storage and custom flash providers
• Build, test, and contribute
• Troubleshooting and current limits

Bring it to your bench

Try UARTBuddy on your next hardware debugging session. If it helps, star the repository or share it with another embedded developer. Found a rough edge? Open an issue with your setup and reproduction steps; please redact sensitive device logs and paths. Pull requests are welcome.

Built with Rust + egui. Open source under the MIT license.