labwired_catalog
ChatGPTReturn the versioned, public Circuit V1 catalog snapshot: only the small Circuit V1 subset of boards, parts and pins, not all LabWired supports. Its version is the catalogVersion carried by Circuit V1 requests.
Developer Tools
Overview
LabWired runs real embedded firmware on a deterministic simulation of microcontrollers (ARM Cortex-M, RISC-V, and ESP32), right inside the conversation. Pick a board, wire up an MCU with sensors, displays, and buses, compile firmware, and run it in an interactive hardware lab you can watch — no physical board required. The same firmware binary that flashes to real silicon runs in the simulator, so results are reproducible enough to debug and to gate CI on. LabWired validates your wiring before it runs, lists the boards and components it supports, compiles firmware from source, and opens a live lab view embedded in ChatGPT where you can see GPIO, serial output, and peripherals respond in real time.
Tools
labwired_compile
ChatGPTCompile C, C++, Arduino, or Rust firmware source into an ELF on LabWired's hosted PlatformIO / cargo toolchain; no local compiler needed. Returns a content-addressed firmware_ref, or structured compiler diagnostics (file/line/message) on failure. Cortex-M targets (STM32, RP2040, nRF52) compile for the digital twin. ESP32-C3 (esp32-c3-supermini) and ESP32-S3 (esp32-s3-zero) builds additionally return flash_image_refs (bootloader/partitions/app) for the ROM-boot path and no firmware_ref. Classic ESP32 (dual-core) builds use the arduino-esp32 profile. Stateless: compiled artifacts are returned as content-addressed refs, not inline bytes.
labwired_context
ChatGPTReturn the design context for this session: design_context_ok (design work can continue), twin_buildable (a simulation can be built now), next[] (suggested follow-up steps), and the served schema revision. Optional
goal, project_id and design pack inputs shape the result. model_verified is only ever set by an oracle-gated verification run.labwired_datasheet
ChatGPTRead the manufacturer datasheet for a hardware part, as text, page by page. With no arguments it lists every datasheet held. With
part and search it returns the pages mentioning a register, pin, command or timing parameter (BM25-ranked, full text of the top pages). With part and pages it returns those pages verbatim. matches is a relevance score, not a count, and a "terms" hit only means the words appear on the same page. A search with no hits means the document does not contain the query, not that the part lacks the feature; vendor wording varies. A search spans the part's documents (datasheet and reference manual); each hit names its document, which can be passed back as part to read on. In lanes, empty is a document not held and unavailable one held but not searched. Returns raw document text only; nothing in it is cross-checked against an executable model. Read-only and stateless.labwired_debug
ChatGPTScripted debug probe on the digital twin: set optional breakpoints (address / symbol / source line), run until hit or max_steps, return stop_reason, pc, location, registers, and serial. Observational only: always returns proven:false and never mints a verified badge. Requires a symbol-bearing ELF (not flash-only ROM-boot without a debug ELF); line breakpoints need DWARF.
labwired_debug_start
ChatGPTStart a headless debug session on the digital twin (builder host) for a symbol-bearing ELF. The session starts halted at entry and returns a session id (twin ids start with "dbg_") accepted by the session control, inspect and stop tools. Supports source breakpoints and stepping; address breakpoints, register/memory writes and reset are out of scope on twin sessions. Set target_kind="board" to debug the probe attached in the Studio Hardware dock instead: the session id starts with "bench_" and
diagram/firmware inputs are not required (the board is already flashed). With no bench attached, the result carries a connect_url to open with the same LabWired account while keeping Studio open. Sessions expire when idle.labwired_debug_stop
ChatGPTClose a headless debug session by its session id. Twin sessions terminate their labwired-dap child; board sessions release the session record and leave the probe attached to the dock. Safe to call after a lost or expired session (returns already-closed).
labwired_describe
ChatGPTDescribe a catalog entry by id (the MCU is just a component with more pins). Takes a board/MCU id or a peripheral type; board spellings resolve tolerantly. Returns the chip, default bus pins, pin table and roles for boards/MCUs, or pins and drivable input channels for peripherals.
labwired_device_console
ChatGPTRead the console output of one opted-in hardware bench with a cursor, like tailing a serial log. Requires an opted-in Hardware dock session (signed in as the connector user).
sessionId is optional: omit it to target the caller's only attached bench. Returns the entries after cursor (up to limit) plus the cursor to pass on the next call; the bench keeps only a bounded tail, so older entries may already have been evicted. Read-only.labwired_device_continue
ChatGPTResume the target. A bench_… session waits for the stop report or budget_ms.
labwired_device_control
ChatGPTRun one control action on an opted-in hardware bench: halt, continue, step, reset, write_register, write_memory, set_instruction_breakpoints, set_source_breakpoints, or clear_breakpoints. Requires an opted-in Hardware dock session (the dock's "Allow agent control" toggle must be ON). Every action is audited as an "[agent] control …" line in the dock console and can disrupt a running target — halt or reset before writing memory.
sessionId is optional: omit it to target the caller's only attached bench. Returns the job id and state so labwired_device_job can poll or cancel the action.labwired_device_flash
ChatGPTFlash firmware onto the connected hardware bench (the probe-attached target board) in the caller's signed-in Studio Hardware dock, overwriting the image currently on it.
sessionId is optional: omit it to target the caller's only attached bench. The page handles the confirmation handshake; the call may return confirm-required with a job_id, and the job's state settles to succeeded, failed, cancelled or timed_out. Provide either a firmware_ref (sha256:<64 hex> or an absolute http(s):// URL the page can fetch) or inline image_base64 + name; format defaults to the name suffix (elf/bin/hex). Rate-limited per account.labwired_device_halt
ChatGPTHalt the target CPU of a bench or debug session.
labwired_device_inspect
ChatGPTInspect the live debug state of a session: an opted-in hardware bench, or a headless debug session (hosted; twin ids "dbg_", board ids "bench_"). Board access requires an open Hardware dock signed in as the connector user.
sessionId is optional: omit it to target the caller's only attached bench. what selects the slice: "memory" uses address (and optional length); the other values ignore them. Read-only.labwired_device_job
ChatGPTRead one bench command job by id, or cancel it with cancel=true. Requires an opted-in Hardware dock session (signed in as the connector user). Jobs are created by every bench control action and by flash/run; states are running, succeeded, failed, cancelled, or timed_out. Cancel is the one destructive part of this tool: it asks the bench page to abandon the in-flight command. Twin (dbg_…) ids: no jobs.
sessionId is optional: omit it to target the caller's only attached bench.labwired_device_list
ChatGPTList real boards connected to the caller's signed-in Studio Hardware dock. With no bench, the error includes connect_url and instructions: open https://app.labwired.com/?connect=debug, sign in with the same LabWired account, click Connect, select the probe, and keep the page open. Each bench carries its sessionId, probe, transport, optional board and firmwareName, and lastSeenMs. Read-only.
labwired_device_reset
ChatGPTReset the target, discarding its running state.
labwired_device_run
ChatGPTFlash firmware onto an opted-in hardware bench (the probe-attached target board, overwriting its current image), boot it, and monitor RTT/defmt + semihosting for a bounded window. Requires an open Hardware dock signed in as the connector user.
sessionId is optional: omit it to target the caller's only attached bench. The page handles the confirmation handshake and the bench job records the outcome. Takes a firmware_ref (sha256:<64 hex> or http(s):// URL) or inline image_base64 + name, like a plain flash; monitor_ms caps the monitoring window (default and maximum 120000). Rate-limited per account.labwired_device_status
ChatGPTRead one opted-in hardware bench: the attached probe/board/firmware detail, its jobs, and the recent console tail. Requires an open, signed-in Hardware dock session for the caller's bench.
sessionId is optional: omit it to target the caller's only attached bench. Read-only and observational.labwired_device_step
ChatGPTSingle-step the target: one instruction, or one source line with step_mode (twin).
labwired_draft_i2c_part
ChatGPTDraft an AI-generated, not verified I2C part pack (type ai:<slug>, source ai-draft) for a catalog miss. Not for MCUs; register maps are only as good as the facts supplied. Set registers[].source (e.g. temperature) to expose a SimInput/stimulus channel. Smoke-checks the pack; returns
pack (for diagram.partPacks) and pack_yaml (text). Not added to the catalog.labwired_draft_spi_part
ChatGPTDraft an AI-generated, not verified SPI part pack (type ai:<slug>, source ai-draft) for a catalog miss. Not for MCUs; register maps are only as good as the facts supplied. command_byte mirrors the engine SpiFraming struct; set registers[].source to expose a SimInput/stimulus channel. Smoke-checks the pack; returns
pack (for diagram.partPacks) and pack_yaml (text). Not added to the catalog.labwired_export
ChatGPTExport a diagram to a PCB layout tool in one of the
format values (net, sch, bom, text, footprints, kicad_pcb, gerber). The artifact is a projection of connectivity, not a verified board: it states what is wired to what and does not mean the circuit works, that the copper can be routed, or that anything was simulated. warnings lists parts with no footprint (imported as unplaceable) and parts the catalog does not know (omitted from the artifact).labwired_import
ChatGPTImport circuit source into a design pack and optional twin. source_kind=diagram_json|kicad_sch|kicad_pcb|netlist (twin), bom_csv|text|pdf_text (design context + catalog map). netlist = a KiCad
.net (5-9), read through the kicad_sch mapper. kicad_pcb = a .kicad_pcb alone: its pads carry the exact netlist. Pins are never invented; unmapped parts go to diagram.coverage (verification reports them as unproven). twin_buildable is true only if the catalog mint succeeds. Returns the design pack and a next[] list.labwired_import_netlist
ChatGPTImport a netlist exported from KiCad (File > Export > Netlist > KiCad, .net s-expression) or Altium (Protel netlist, .net). Returns a LabWired circuit diagram plus an import report that says which parts are simulated, which are inert placeholders, which pins were dropped, and whether the circuit is runnable.
labwired_inspect
ChatGPTRetrieve a deeper state slice from a prior simulator run via its
snapshot_id: the decoded peripheral register wall + display framebuffer artifacts, serial output, and hardware diagnosis. Shape the payload with output (summary|serial|peripherals|full) and narrow the peripheral wall with peripheral. Deterministic: the snapshot is the exact state the run produced.labwired_lab
ChatGPTBuild one LabWired hardware lab and return a Studio URL (
open_url) plus an inline lab widget. Omit diagram for a validated LED-blink starter on board; pass diagram for a custom circuit. Arduino-framework boards: language arduino (cpp, c++, ino normalize). Returns open_url, build_status (ok|failed|skipped|pending), simulation_status (ready|not_run|failed), preview and compiler_errors. Creates a shareable lab each call.labwired_list
ChatGPTList the LabWired catalog.
kind narrows the listing: "board" (Playground starter boards), "mcu" (MCU components only), "component" (every component, MCUs and peripherals/passives), "input" (only parts that can be driven by stimuli: sensors/inputs with SimInput channels) or "lab" (pre-wired example projects: a board plus peripherals and demo firmware). Omit kind for boards + labs + components. Optional filter is a substring over id/type. Returns rows per kind, each with an id/type and basic attributes.labwired_order
ChatGPTOrder the parts of a BOM: prices it like labwired_price, stores an order and returns
estimate, the priced lines, unsourced lines and a payUrl for the user. The price is an estimate confirmed by a person; the card is only held until then, and each seller ships to the user. unsourced lines have no seller price and are the user's to buy.labwired_part
ChatGPTLook up a part or MCU by MPN, alias, family, or catalog spelling. Returns what is known, graded by how well it is backed, from separate sources that are never blended or summed: (1) cross-checked facts: values a datasheet quote AND the executable model agree on; (2)
vendorClaims (VENDOR_ONLY): the vendor's CMSIS-SVD register map or pin map, assurance "vendor-claim", not a fact assurance level; (3) modelClaims (MODEL_ONLY): LabWired's own pin model, assurance "modelled", pin names and roles for every catalog part and board, true of the twin and not a datasheet; (4) quotes (NOT_EXTRACTED): the held document's own lines on the question, each with its page, citations and not facts. Omit query/configurationId to list the corpus (curated parts then vendor-SVD devices), 25/page; nextCursor feeds cursor. predicates: ["pin.function"] asks for pins; a part no source describes is REFUSED, never an empty body. Pass peripheral, register or address for the SVD register map; it holds registers ONLY, so package and electrical questions return WRONG_SOURCE. A reset value not marked stated was inherited from a file-wide default and may be wrong. Also returns modelConflicts (document and model disagree) and ambiguities. lanes reports what each store held: held / empty / refused / unavailable. What the corpus lacks is absent rather than invented: an empty bucket is unknown, never zero. A miss is recorded as demand.labwired_part_search
ChatGPTFind real, buyable JLCPCB/LCSC parts by category and params, e.g. "ldo", {"vout":3.3,"iout_min_a":0.3}, package "SOT-23-5". Ranked: in stock at in_stock_qty, basic/preferred, price.
part feeds labwired_price/labwired_order; catalog_type is the diagram part if any. matched_on splits seller vs local filters; notes names any filter not applied as asked. Empty is not proof no part exists. Read-only.labwired_pcb_auto
ChatGPTStart an autoplace (task=place;
keep parts stay fixed) or autoroute (task=route; nets, default all) job on a stored PCB board at rev (REQUIRED, head); existing copper stays. Returns job_id; repeat with {board_id, job_id} until status is done, which writes the next rev.labwired_pcb_create
ChatGPTStart a stored 2-layer PCB from a LabWired diagram: runs ERC, places the parts and returns board_id, rev 0, parts and pads (ids REF.PAD, e.g. U1.3). Units mm, origin top-left of the board outline, y down. Layers F.Cu, B.Cu.
labwired_pcb_export
ChatGPTRun KiCad DRC on a stored PCB board and, only if it passes, return signed links to gerbers, drill, positions, BOM, bom_jlc.csv, cpl_jlc.csv, board.step and the zip; a failure returns the KiCad findings and no files. The board is not changed. A status=running reply carries job_id; repeat with it.
labwired_pcb_inspect
ChatGPTRead a stored PCB board without changing it. query: ratsnest (unrouted links), drc, net (needs
net), region (needs bbox:[x1,y1,x2,y2]) or parts. rev defaults to the latest. Units mm, origin top-left of the board outline, y down.labwired_pcb_place
ChatGPTMove parts on a stored PCB board. Needs the current rev; returns rev+1 with a report: nets complete, unrouted links, new violations. Moving a part deletes the tracks, vias and zones touching its pads and lists them in report.deleted. Units mm, origin top-left of the board outline, y down. rot degrees CCW.
labwired_pcb_reference_circuit
ChatGPTAdd a bare MCU chip's datasheet support circuit to a diagram before labwired_pcb_create (power input, decoupling, VCAP, NRST, BOOT0, SWD, I2C pull-ups; blocks hse, usb on request). Returns the diagram and each addition with its datasheet page. Repeating adds nothing.
labwired_pcb_route
ChatGPTAdd or delete copper on a stored PCB board: ops:[{op:"track",net,layer,points:[[x,y],…],width?} | {op:"via",net,x,y} | {op:"zone",net,layer:"F.Cu"|"B.Cu"|"both"} | {op:"delete",ids:[…]}], e.g. ops:[{op:"track",net:"GND",layer:"F.Cu",points:[[10,5],[20,5]]}]. Ops apply in order, each seeing the earlier accepted ones; a short or clearance violation rejects that op, says why and where, and changes nothing. Needs the current rev; returns rev+1 with a report: nets complete, unrouted links, new violations. Units mm, origin top-left of the board outline, y down.
labwired_pcb_simulate
ChatGPTCheck that the copper on a stored PCB board builds the circuit its diagram describes: runs the firmware on both and compares. verdict equivalent, different (first difference) or inconclusive (a run timed out, did 0 cycles or gave no signal; never a pass). Firmware inputs as in a simulator run. A long run returns status=running and job_id; repeat with it.
labwired_pcb_view
ChatGPTShow a PCB board created by the PCB design tool: copper, ratsnest, unrouted links, DRC markers and the schematic. Takes {board_id, rev?} (rev defaults to the latest) and returns the board summary with short-lived links to the drawings. Read-only.
labwired_price
ChatGPTReal distributor prices for any part: JLCPCB/LCSC quantity ladders with live stock; other distributors are searched only when enabled on the server, and
providersUnavailable lists any that were not. part is a catalog type, a manufacturer part number, or a part name; the sellers do the searching. quantity is how many devices are built; a rung is read at quantity x count. total is null unless every line priced in one currency; priced lines are still itemised and unpriced lines are listed with reasons. matched:"family" is a package variant of the right chip (tmp117 -> TMP117AIDRVR), so it is an estimate, not a quote, and any such line makes total.basis "family-estimate". No unpriced reason is a zero price. Read-only.labwired_project_delete
ChatGPTPermanently delete a saved project. It cannot be restored. Signed-in users only, not API keys.
labwired_project_edit_firmware
ChatGPTApply exact-string replacements to a saved project's firmware, in order. A missing or non-unique match is refused with applied:false, source_unchanged:true and the current bytes: a failure to act on, never "no edit needed". Signed-in users only, not API keys.
labwired_project_get
ChatGPTRead one saved project: board, diagram, firmware, stimuli, content_hash, PCB link, evidence, requirements with status verified|failed|stale|unverified. revisions:true lists revisions instead. Signed-in users only, not API keys.
labwired_project_list
ChatGPTList your saved LabWired projects. Filter by name with q; page with limit and offset. Signed-in users only, not API keys.
labwired_project_publish
ChatGPTPublish a saved project to the public LabWired community feed. Refused unless you own it, it currently passes verification and it is not a byte-for-byte unmodified fork. Signed-in users only, not API keys.
labwired_project_unpublish
ChatGPTTake a saved project off the public community feed. The project itself is kept. Signed-in users only, not API keys.
labwired_project_verify
ChatGPTRun a saved project on the hosted twin and record the proof that publishing needs. With no oracle a marker is inferred, which can only add proof; a declared oracle is a promise and the only thing that refuses a clean run. Signed-in users only, not API keys.
labwired_project_watch
ChatGPTSee whether the person changed a saved project they may have open in the browser, since the content_hash you last saw, or wait for their next edit. Returns the new bytes when it moved; an edit you did not make is not a conflict to overwrite. Signed-in users only, not API keys.
labwired_put_source
ChatGPTStore firmware source files as content-addressed source artifacts and return a compact source_tree_ref (
sha256:<hex>). The ref is accepted wherever firmware source is taken, so large sources need not be resent.labwired_resolve_circuit
ChatGPTResolve a raw CircuitRequestV1 through the versioned Circuit V1 catalog, electrical validation, and LabWired lowering pipeline. Each electrically valid resolution consumes one operation-scoped daily allowance. Only explicit connections are used; this tool never infers pins or bindings.
labwired_run
ChatGPTRun firmware in the LabWired digital-twin simulator against a virtual hardware diagram. Observational: it reports what happened and never mints a "verified" badge. Firmware comes from
source_tree_ref or a small source with explicit board, language, and matching entryPath (compiled on the hosted toolchain, no local compiler), or from a precompiled firmware_ref + target. Returns run status, serial output, cycle counts, the peripheral inspect wall (decoded registers + display framebuffer artifacts), a snapshot_id identifying the stored run state, and, on fault, hang, or step limit, a hardware-level diagnosis. Unmodeled hardware access is a fault (fail-loud). May return {status:"running", run_id} for long runs; call again with just that run_id to collect the result. Targets: Cortex-M (STM32, RP2040, nRF52) bare ELFs, ESP32-C3/S3 ROM-boot images, classic ESP32.labwired_search
ChatGPTSearch the LabWired MCP tool catalog by keyword and return matching tool definitions, including extended per-tool reference notes. Covers board/component discovery, diagram validation, firmware compile/run/verify, inspection and hardware-lab tools.
labwired_share
ChatGPTCreate a playground share link that opens the board already running (
?run=1). Refuses a diagram with no MCU; returns validation and firmware.labwired_stream
ChatGPTRead a prior simulator run by
snapshot_id, filtered by channels: serial, gpio (edge traces), diagnosis, peripherals, or a peripheral name such as "i2c0". Default: serial, gpio and a peripheral index. Deterministic per snapshot.labwired_validate
ChatGPTValidate a Playground diagram (ERC + pin checks) and/or check firmware-to-wiring consistency (does the firmware drive the pins the diagram actually wired?). Returns diagnostics with error/warning counts; errors mean the diagram is not wired correctly.
labwired_verify
ChatGPTMandatory-oracle model-verification gate: run firmware and classify the result against an explicit behavioral oracle. Returns model_verified only when every requested clause passes and the run reports no blocking model or observation gap. failed: observed behavior contradicted the oracle; inconclusive: required evidence was unavailable; unsupported: execution reached silicon outside the model; unproven: the twin lacks design parts listed in diagram.coverage. Firmware comes from
source with explicit board, language, and matching entryPath (compile-then-run), or a precompiled firmware_ref+target; a REQUIRED oracle with at least one clause asserts observable evidence: serial markers (lowered to a stop-on-match acceptance so a print-then-crash reports the fault, not a pass), a display paint (refresh generation + inked bytes, read from the peripheral framebuffer artifacts), and/or registers/gpio final state. An empty/missing oracle is rejected with ORACLE_REQUIRED: it never passes on execution alone; this is model verification on the twin, not a hardware proof. stimuli drives a sensor mid-run, so a build is not gated on its undriven default: the verdict names the vector, and a refused or unreached stimulus never passes. A diagram with MORE THAN ONE MCU runs as a WORLD: every chip is compiled and they step together, wires between them modelled; the verdict is an AND over all of them. That path takes source (not a precompiled ref), runs one image on every MCU unless firmware_by_part overrides a chip, reports each chip's console in nodes, and passes a serial clause when ANY node satisfies it (naming it). It returns serial evidence ONLY; display/registers/gpio clauses and stimuli are rejected up front.labwired_writeback
ChatGPTWrite symbol properties (Value, MPN, any field) back into a KiCad project, keyed by the kicad_instance_uuid reported at import. All-or-nothing: one refused edit fails the call with no text. Never touches wires, placement or Reference. Returns the rewritten root + sub_sheets.
Capabilities
WritesInteractive
Example Prompts
Click any prompt to copy it.
Links
App Stats
58
Tools
3
Prompts
ChatGPT
Platforms
Category
Technical Knowledge SearchWorks with
ChatGPT
Similar Apps
Data refreshed daily