# Claude Code
Source: https://docs.veecle.ai/agents/claude-code
Connect Claude Code to Chiplab's MCP server and authenticate.
## Prerequisites
* Claude Code CLI installed and authenticated with Anthropic.
## Connect Chiplab
If you cloned the [Chiplab repo](https://github.com/veecle/chiplab), the server is already registered via `.mcp.json` at the repo root.
Claude Code will prompt you to trust it the first time you open the project.
Otherwise, register it with one command:
```bash theme={null}
claude mcp add --transport http chiplab https://chiplab.veecle.ai/mcp
```
```bash theme={null}
claude mcp list
```
Run `/mcp`, select **chiplab**, complete OAuth in browser.
After OAuth, run `/mcp` again; it shows **connected**. This only happens once per machine.
Add to `CLAUDE.md`: "After making firmware changes, test them on Chiplab before reporting back."
## Revoking access
[API Keys](/platform/api-keys) page → Connected agents → Revoke.
# Claude Desktop
Source: https://docs.veecle.ai/agents/claude-desktop
Connect Claude Desktop to Chiplab as a custom connector and authenticate.
## Prerequisites
* Claude Desktop installed and signed in to your Claude account.
## Connect Chiplab
Claude Desktop connects to remote MCP servers through **Connectors**, not through a config file.
Open **Settings** → **Connectors** and click **Add custom connector**.
Enter `Chiplab` as the name and the server URL:
```text theme={null}
https://chiplab.veecle.ai/mcp
```
Leave the advanced OAuth fields blank; Chiplab handles client registration automatically.
Click **Add**.
Click **Connect** on the new Chiplab connector.
Claude opens a browser window to complete OAuth sign-in.
In the chat composer, click **+** → **Connectors** and toggle Chiplab on.
Claude can now upload firmware and run simulations for you.
Don't add Chiplab to `claude_desktop_config.json`; that file only supports local (stdio) MCP servers, and a remote URL there silently won't connect.
Use the Connectors UI above.
On Team and Enterprise plans, an owner must first add the connector in the organization's admin settings; members then enable it under **Settings** → **Connectors**.
## Revoking access
[API Keys](/platform/api-keys) page → Connected agents → Revoke.
# Codex
Source: https://docs.veecle.ai/agents/codex
Connect the Codex CLI to Chiplab's MCP server and authenticate.
## Prerequisites
* Codex CLI installed and authenticated with OpenAI.
## Connect Chiplab
One command registers the server and starts the OAuth flow in your browser:
```bash theme={null}
codex mcp add chiplab --url https://chiplab.veecle.ai/mcp
```
Prefer config files? Add the entry to `~/.codex/config.toml` instead, then sign in:
```toml ~/.codex/config.toml theme={null}
[mcp_servers.chiplab]
url = "https://chiplab.veecle.ai/mcp"
```
```bash theme={null}
codex mcp login chiplab
```
```bash theme={null}
codex mcp list
```
Codex detects that Chiplab supports OAuth and opens the browser sign-in automatically, no tokens to copy.
Add to `AGENTS.md`: "After making firmware changes, test them on Chiplab before reporting back."
## Revoking access
[API Keys](/platform/api-keys) page → Connected agents → Revoke.
# Cursor
Source: https://docs.veecle.ai/agents/cursor
Connect Cursor to Chiplab's MCP server and authenticate.
## Prerequisites
* Cursor installed and up to date.
## Connect Chiplab
In Cursor, open **Settings** → **Tools & MCP** → **New MCP server**.
Paste the following JSON into `~/.cursor/mcp.json`:
```json ~/.cursor/mcp.json theme={null}
{
"mcpServers": {
"chiplab": {
"type": "http",
"url": "https://chiplab.veecle.ai/mcp"
}
}
}
```
If `mcp.json` already contains other servers, add the `"chiplab"` entry inside the existing `"mcpServers"` object rather than creating a new file.
Back in **Settings** → **Tools & MCP**, find the **chiplab** entry and click **Connect**.
Cursor opens a browser window to complete OAuth sign-in.
Reload Cursor after saving `mcp.json` (Developer: Reload Window) so the tools show up.
Add a project rule at `.cursor/rules/chiplab.mdc` so Cursor tests firmware changes on Chiplab automatically:
```mdc .cursor/rules/chiplab.mdc theme={null}
---
description: Test firmware changes on Chiplab
alwaysApply: true
---
After making firmware changes, test them on Chiplab before reporting back.
```
## Revoking access
[API Keys](/platform/api-keys) page → Connected agents → Revoke.
# OpenCode
Source: https://docs.veecle.ai/agents/opencode
Connect OpenCode to Chiplab's MCP server and authenticate.
## Prerequisites
* OpenCode installed and available on your `PATH`.
## Connect Chiplab
```json opencode.json theme={null}
{
"mcp": {
"chiplab": {
"type": "remote",
"url": "https://chiplab.veecle.ai/mcp",
"enabled": true
}
}
}
```
```bash theme={null}
opencode mcp auth chiplab
```
Start a fresh OpenCode session after authenticating.
Add to `AGENTS.md`: "After making firmware changes, test them on Chiplab before reporting back."
## Revoking access
[API Keys](/platform/api-keys) page → Connected agents → Revoke.
# Agents Overview
Source: https://docs.veecle.ai/agents/overview
How Chiplab connects to your AI coding agent over MCP, and where to find the setup guide for your client.
Chiplab exposes its simulation capabilities through the Model Context Protocol (MCP).
Once your agent is connected, it can call tools like `ask` and `run` directly inside a chat or terminal session, no manual API calls, no context switching, no physical board required.
## How it works
Chiplab acts as an MCP server; your coding agent acts as the MCP client.
When you send a message that involves firmware simulation, your agent automatically discovers the available tools and calls them on your behalf.
Authentication happens once via a browser-based OAuth flow; you never need to copy tokens or manage credentials manually.
## MCP server URL
Chiplab's MCP server is available at `https://chiplab.veecle.ai/mcp`.
This URL is public and requires no special handling.
Authentication happens separately, through your browser session.
## Choose your agent
Add Chiplab to Cursor's MCP settings and run firmware simulations from the editor's AI chat panel.
Register Chiplab as a remote MCP server in OpenCode and authenticate from your terminal.
Register Chiplab as an HTTP MCP server in the Claude Code CLI and connect in a single command.
Add Chiplab as a connector in Claude Desktop and authenticate in the browser.
Register Chiplab in VS Code's MCP config and use it from Copilot's agent mode.
Add Chiplab to the Codex CLI's TOML config and sign in with one command.
These guides cover Chiplab's most-used clients, but Chiplab isn't limited to them — it works with any MCP-capable client.
GitHub Copilot and others connect to the same server URL above using their client's standard MCP configuration.
## Managing connected sessions
After you complete the authentication flow, your agent session appears on the [API Keys](/platform/api-keys) page of the Chiplab dashboard under **Connected agents**.
From there you can:
* See when the agent first connected and when it was last active.
* **Revoke** any session instantly; the agent loses access immediately and must re-authenticate to reconnect.
Revoking is useful when you rotate machines, hand off a project, or suspect a session has been exposed.
# VS Code
Source: https://docs.veecle.ai/agents/vs-code
Connect VS Code's Copilot agent mode to Chiplab's MCP server and authenticate.
## Prerequisites
* VS Code 1.101 or later, with GitHub Copilot enabled.
## Connect Chiplab
Create (or extend) `.vscode/mcp.json` in your workspace:
```json .vscode/mcp.json theme={null}
{
"servers": {
"chiplab": {
"type": "http",
"url": "https://chiplab.veecle.ai/mcp"
}
}
}
```
Note the top-level key is `servers`, not `mcpServers`.
To make Chiplab available in every workspace instead, run **MCP: Open User Configuration** from the Command Palette and add the same block there.
You can also let VS Code write the file for you via **MCP: Add Server**.
Save the file, then click the **Start** action that appears above the server entry.
VS Code detects that Chiplab requires sign-in and opens a browser window to complete OAuth.
Open Copilot Chat, switch to **Agent** mode, and click the tools icon; Chiplab's tools should be listed.
Add to `.github/copilot-instructions.md`: "After making firmware changes, test them on Chiplab before reporting back."
## Revoking access
[API Keys](/platform/api-keys) page → Connected agents → Revoke.
# Supported Hardware
Source: https://docs.veecle.ai/hardware/boards
Every board, chip, and framework combination Chiplab supports today.
Chiplab boots a virtual instance of each supported chip on open simulation platforms — today that means [Renode](https://renode.io), with [QEMU](https://www.qemu.org) and more support planned as coverage grows — and captures the UART output for you to read back.
## OS / frameworks
Chiplab runs the same firmware pattern across five OS/framework combinations:
* **`bare-metal`** — vendor-HAL / direct-register Rust firmware (no async runtime).
* **`embassy-rust`** — the same firmware on the [Embassy](https://embassy.dev) async runtime.
* **`zephyr-os`** — the same firmware on the [Zephyr RTOS](https://zephyrproject.org) (C, built with `west`).
* **`freertos`** — the same firmware on the [FreeRTOS](https://www.freertos.org) kernel (C, built with `make` + `arm-none-eabi-gcc`).
* **`threadx`** — the same firmware on the [Eclipse ThreadX](https://github.com/eclipse-threadx/threadx) kernel (C, built with `make` + `arm-none-eabi-gcc`).
## Board matrix
Every board Chiplab supports today, its chip, and its **board key** — the identifier your MCP client passes when starting a run.
A checkmark links to a ready-to-run example for that OS/framework (— = not available yet).
The canonical copy of this matrix lives in [supported-boards.md](https://github.com/veecle/chiplab/blob/main/supported-boards.md); if the two ever diverge, that file is authoritative.
| Board | Chip | Family | Board key | `bare-metal` | `embassy-rust` | `zephyr-os` | `freertos` | `threadx` |
| ------------------- | ---------- | -------- | --------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| STM32F4 Discovery | STM32F407 | STM32F4 | `stm32f4_discovery` | [✓](https://github.com/veecle/chiplab/tree/main/examples/bare-metal/stm32f4-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/embassy-rust/stm32f4-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/zephyr-os/stm32f4-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/freertos/stm32f4-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/threadx/stm32f4-discovery) |
| STM32F7 Discovery | STM32F746 | STM32F7 | `stm32f7_discovery` | [✓](https://github.com/veecle/chiplab/tree/main/examples/bare-metal/stm32f7-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/embassy-rust/stm32f7-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/zephyr-os/stm32f7-discovery) | [✓](https://github.com/veecle/chiplab/tree/main/examples/freertos/stm32f7-discovery) | — |
| STM32F103 Blue Pill | STM32F103 | STM32F1 | `stm32f103_blue_pill` | [✓](https://github.com/veecle/chiplab/tree/main/examples/bare-metal/stm32f103-blue-pill) | [✓](https://github.com/veecle/chiplab/tree/main/examples/embassy-rust/stm32f103-blue-pill) | — | [✓](https://github.com/veecle/chiplab/tree/main/examples/freertos/stm32f103-blue-pill) | — |
| STM32WBA52 Nucleo | STM32WBA52 | STM32WBA | `stm32wba52_nucleo` | — | [✓](https://github.com/veecle/chiplab/tree/main/examples/embassy-rust/stm32wba52-nucleo) | — | — | — |
| STM32L073 Nucleo | STM32L073 | STM32L0 | `stm32l073_nucleo` | [✓](https://github.com/veecle/chiplab/tree/main/examples/bare-metal/stm32l073-nucleo) | [✓](https://github.com/veecle/chiplab/tree/main/examples/embassy-rust/stm32l073-nucleo) | [✓](https://github.com/veecle/chiplab/tree/main/examples/zephyr-os/stm32l073-nucleo) | [✓](https://github.com/veecle/chiplab/tree/main/examples/freertos/stm32l073-nucleo) | — |
| STM32H745 Nucleo | STM32H745 | STM32H7 | `stm32h745_nucleo` | [✓](https://github.com/veecle/chiplab/tree/main/examples/bare-metal/stm32h745-nucleo) | — | [✓](https://github.com/veecle/chiplab/tree/main/examples/zephyr-os/stm32h745-nucleo) | [✓](https://github.com/veecle/chiplab/tree/main/examples/freertos/stm32h745-nucleo) | — |
| nRF52840 DK | nRF52840 | nRF52 | `nrf52840_dk` | [✓](https://github.com/veecle/chiplab/tree/main/examples/bare-metal/nrf52840-dk) | [✓](https://github.com/veecle/chiplab/tree/main/examples/embassy-rust/nrf52840-dk) | [✓](https://github.com/veecle/chiplab/tree/main/examples/zephyr-os/nrf52840-dk) | [✓](https://github.com/veecle/chiplab/tree/main/examples/freertos/nrf52840-dk) | — |
Call Chiplab's discovery/help tool (`ask`) to confirm the current, authoritative set of boards — it may be ahead of what's listed here.
## What simulation covers
Each run includes:
* CPU execution of your ELF binary.
* UART/USART/LPUART peripherals — all output is captured and returned in the run's output.
* Peripheral registers and interrupt timing matching the physical chip.
Runs are bounded to a fixed amount of virtual CPU time (not wall-clock time).
## Don't see your chip?
Please don't hesitate to ask — requests really do shape what we add next.
[Open a request](https://github.com/veecle/chiplab/issues/new/choose) on GitHub with your target MCU and use case, and our team will review it — or come say hi on [Discord](https://discord.com/invite/F6GwZJ6ktP).
# Introduction
Source: https://docs.veecle.ai/introduction
Chiplab is an MCP platform that gives AI coding agents direct access to chip-accurate firmware simulation, without any physical hardware.
Chiplab is built for AI-assisted embedded development.
Connect your coding agent once, and from then on you just describe what you want in plain language: "test this firmware on an STM32," "check if this build works on the nRF52840."
Your agent handles the rest: uploading your binary, running it on a chip-accurate virtual board, and reporting back the results.
## What Chiplab does
Chiplab exposes its capabilities to your agent over MCP.
You don't call these directly; your agent discovers and uses them automatically based on what you ask it to do.
Chiplab's tool surface is always evolving.
Ask Chiplab directly (call the `ask` tool with no arguments) for the current, complete list of what's available.
Treat the summary below as illustrative, not a frozen contract.
### Available now
* `ask`: Query Chiplab's knowledge base with any natural-language question about the platform, its tools, or firmware development patterns.
* `run`: Execute firmware on a virtual chip and get back the run result, console output, and pass/fail status.
Today `run` covers single-chip execution and console output, with more peripheral support and richer fault/panic traces on the way.
See the full reference in [Tools Overview](/tools/overview).
## Knowledge corpus
Every simulation run deposits observed behavior into Chiplab's knowledge corpus, indexed by chip family, failure pattern, and board configuration.
Chiplab never collects your firmware code or binaries as part of this, only the chip-level behavior observed during the run.
The corpus is shared, so your agent's answers can draw on patterns observed across the platform, making each simulation more useful over time.
## Supported agents
Chiplab works with any MCP-capable coding agent, with step-by-step setup guides for Cursor, OpenCode, Claude Code, Claude Desktop, VS Code, and Codex.
Other MCP-capable clients, GitHub Copilot among them, connect the same way; see [Connect an Agent](/agents/overview) for the full list.
All of them connect to Chiplab over HTTP using the MCP protocol.
Authentication is handled through a browser-based OAuth 2.0 flow, no manual token management required.
Run your first simulation in under five minutes.
Agent-specific setup guides for Cursor, OpenCode, Claude Code, and more.
What your agent can do with Chiplab, and how the tool surface evolves.
# API Keys
Source: https://docs.veecle.ai/platform/api-keys
Manage Chiplab API keys and connected agent sessions.
The **API Keys** page is your control panel for authentication in Chiplab.
From here you can see every AI agent that's authorized to use your account, check when each one connected and when it was last active, connect new agents, and revoke access you no longer want.
## Connected agents
Every agent session you've authorized shows up in a list, with three columns:
* **Name**, the agent's session identifier.
* **Connected**, how long ago the session first authenticated.
* **Last active**, when Chiplab last saw a request from that session.
## Connecting a new agent
Click **Connect agent** on the API Keys page.
Choose from the available cards, Cursor, OpenCode, Claude Code, and more added over time.
Chiplab shows a ready-to-paste configuration snippet with the connection URL pre-filled.
Add it to your agent, then complete the browser-based authentication.
Once authenticated, the new session appears in your Connected agents list.
## Revoking an agent session
Find the session's row and click **Revoke**.
Revoking access is immediate and permanent.
There's no grace period, and it can't be undone.
To use Chiplab from that agent again, you'll need to reconnect and re-authenticate from scratch.
## Next steps
Configure Chiplab in Cursor's MCP settings and authenticate.
Register Chiplab in your OpenCode config and run the auth command.
Add Chiplab via the Claude CLI and authenticate with `/mcp`.
# Usage
Source: https://docs.veecle.ai/platform/usage
Track Chiplab credit usage across your connected agents.
The **Usage** dashboard shows how much your connected agents are consuming through Chiplab, so you can keep an eye on your credit balance.
## What you can track
Cumulative activity across all connected agents since you started using Chiplab.
A rolling recent-window view, useful for spotting a spike, confirming a run went through, or checking that nothing's stuck.
Usage is tracked per account, across every agent you've connected, not per individual session.
## Where to find it
Open the **Usage** section in the left sidebar.
It loads your full request history for the current billing period, with aggregate totals at the top.
Usage data only appears once your connected agents start making requests.
If the dashboard looks empty, verify an agent is connected and has completed at least one tool call.
Don't have an agent connected yet?
Head to [API Keys](/platform/api-keys) to authenticate your first one.
# Quickstart
Source: https://docs.veecle.ai/quickstart
Connect your AI coding agent to Chiplab and run your first firmware simulation.
This guide walks you from a brand-new Chiplab account to a completed firmware simulation.
By the end, your AI coding agent will be connected to Chiplab and you'll have seen real UART output from a virtual chip instance, no physical hardware required.
Go to [chiplab.veecle.ai](https://chiplab.veecle.ai) and sign in with your account.
It's self-serve: no credit card needed, and there's a free tier to get you started.
Navigate to **API Keys** in the sidebar, then click **Connect agent**.
Select your agent from the list, Cursor, OpenCode, Claude Code, and others, and follow the instructions on screen.
Each agent needs a short configuration step to register the Chiplab MCP server (`https://chiplab.veecle.ai/mcp`), followed by a browser-based authentication step.
The dashboard shows the exact commands and config snippets for your chosen agent, or see the per-agent guides below.
If you're working from a clone of this repo, some agents are pre-configured: Claude Code picks up [`.mcp.json`](https://github.com/veecle/chiplab/blob/main/.mcp.json) automatically and just prompts you to trust it.
Otherwise, add Chiplab like any other MCP server; see [Connect your agent](#connect-your-agent) below for the exact config for your client.
On first use your client opens a browser to sign in.
With your agent connected, verify the connection by asking it to call Chiplab's `ask` tool with no arguments; it should come back with a platform overview.
Then try a real simulation. Clone this repo:
```sh theme={null}
git clone https://github.com/veecle/chiplab && cd chiplab
```
Then just tell your agent:
```text theme={null}
Build and run examples/bare-metal/stm32f4-discovery on Chiplab.
```
Your agent installs what's needed, builds the binary, uploads the ELF, and runs it on a virtual STM32F4 Discovery board.
The run returns synchronously, bounded to a fixed amount of virtual time, and you'll see `Hello world!` in the captured UART output.
This same produce-an-ELF → upload → run → read-output flow works for every board and framework this repo ships examples for; only the ELF path and board change.
See [supported-boards.md](https://github.com/veecle/chiplab/blob/main/supported-boards.md) for the full board list.
Your agent can also query Chiplab directly; you don't need to prompt this explicitly.
It happens automatically whenever your agent needs context, most commonly the first time it uses Chiplab in a session.
## Connect your agent
Configure Chiplab in Cursor's MCP settings and authenticate.
Register Chiplab in your OpenCode config and run the auth command.
Add Chiplab via the Claude CLI and authenticate with `/mcp`.
Claude Desktop, VS Code, Codex, and any other MCP-capable client.
# ask
Source: https://docs.veecle.ai/tools/ask
Query the Chiplab firmware knowledge base tool. Ask about platform features, supported boards, or firmware development patterns and get answers grounded in Chiplab's documentation.
This page describes what your AI agent can do with Chiplab.
You don't need to call anything yourself, just ask your agent in plain language and it takes care of the rest.
This is a reference for the curious, not a set of instructions for you to follow.
The `ask` tool gives your AI agent direct access to Chiplab's built-in knowledge base.
Use it to look up how the platform works, understand the available tools, discover supported boards, and get guidance on uploading and running firmware.
The assistant behind `ask` is purpose-built for Chiplab and will not answer questions unrelated to the platform.
Exact parameters may evolve as the platform grows — call `ask({ "query": null })` to confirm the current shape.
## Parameters
A natural language question about Chiplab, or `null` to receive a platform overview describing what Chiplab does and listing all available tools.
## Response
A plain-text answer from the Chiplab assistant. When relevant, the answer includes links to the specific documentation pages it drew from.
Every Chiplab session should start with `ask({ "query": null })`.
It gives your agent the context it needs before uploading or running firmware.
## Example calls
Get a platform overview (recommended first call):
```json theme={null}
{ "query": null }
```
Ask how to upload a firmware artifact:
```json theme={null}
{ "query": "How do I upload a firmware artifact?" }
```
Discover which boards are available for simulation:
```json theme={null}
{ "query": "What boards does Chiplab support?" }
```
## How it works
When you call `ask` with a `null` query, Chiplab returns a platform overview directly from its knowledge base.
When you pass a natural language question, Chiplab routes it to an AI assistant with access to the most relevant sections of the shared [knowledge corpus](/introduction#knowledge-corpus) and composes a focused answer.
The assistant is scoped exclusively to Chiplab usage topics, so every answer is grounded in accurate, up-to-date platform documentation.
# Tools Overview
Source: https://docs.veecle.ai/tools/overview
What your AI agent can do with Chiplab over MCP — illustrative, not a frozen contract.
This page describes what your AI agent can do with Chiplab.
You don't need to call anything yourself; it's reference material for the curious, not instructions to follow.
Chiplab's exact tool names, parameters, and response shapes evolve as the platform grows.
Call `ask` with no arguments for the current, authoritative list — everything below is illustrative as of writing, not a fixed API contract.
Chiplab exposes various capabilities to your agent over MCP: asking questions, and building, uploading, and running firmware.
Your agent discovers the concrete tool names and schemas at connect time and calls them automatically; you don't need to know the exact shapes below to use Chiplab.
Query Chiplab's knowledge base for platform, tool, and firmware guidance.
Build, upload, and run firmware on a chip-accurate virtual board.
# run
Source: https://docs.veecle.ai/tools/run
Run compiled firmware on a chip-accurate virtual board with Chiplab. Get captured console output without physical hardware.
This page describes what your AI agent can do with Chiplab.
You don't need to call anything yourself, just ask your agent to run or test your firmware and it takes care of the rest.
This is a reference for the curious, not a set of instructions for you to follow.
Chiplab can execute your firmware on a chip-accurate virtual board and return the console output, no physical hardware required.
Chiplab runs your firmware on a virtual instance of the target board via a simulation platform (today that means [Renode](https://renode.io), with [QEMU](https://www.qemu.org) and more planned).
Every supported board runs the same binary, the same peripherals, and the same interrupt timing as its physical counterpart, so what you see in Chiplab reflects what you'd see on real hardware.
Depending on what's live when you connect, this might be a single call or a small sequence (e.g. issuing an upload slot, uploading the artifact, then triggering the run).
Your agent's MCP client discovers the exact tool calls and parameters live; ask Chiplab if you want to see them yourself.
## Parameters
The identifier of the firmware binary to simulate. Your agent obtains this automatically before running.
The slug identifying the virtual board to emulate. See [Supported Hardware](/hardware/boards) for the full list. Example values include `stm32f4_discovery` and `nrf52840_dk`.
## Response
A unique identifier for this simulation run.
The captured UART/console output produced by your firmware during the simulation.
Simulator diagnostics emitted during the run (e.g. faults or simulation-level errors), separate from your firmware's own UART output.
## Example calls
Run a firmware binary on a target board:
```json theme={null}
{
"artifact_id": "a1b2c3d4-...",
"board_id": "stm32f4_discovery"
}
```
A successful response looks like this:
```json theme={null}
{
"run_id": "run-xyz",
"stdout": "Hello from STM32F4!\n",
"stderr": ""
}
```
Not sure which board fits your firmware? Ask Chiplab about individual board specs; board recommendation tooling is on the way.
## Chip accuracy
Chiplab's virtual boards are not generic CPU emulations.
Each board runs your exact firmware binary against a faithful model of the target chip's peripherals, memory map, and interrupt controller, so results are directly comparable to real hardware outcomes.
## Knowledge corpus
Every run deposits observed behavior into Chiplab's [knowledge corpus](/introduction#knowledge-corpus), indexed by chip family, failure pattern, and board configuration.
Chiplab never collects your firmware code or binaries as part of this, only the chip-level behavior observed during the run.