Skip to content
Back to search

labwired-core

Deterministic firmware simulator for microcontrollers with hardware-validated parity. Labwired.com

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/w1ne/labwired-core with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/w1ne/labwired-core'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/w1ne--labwired-core/badge.svg)](/listings/w1ne--labwired-core)

HTML

<a href="/listings/w1ne--labwired-core"><img src="/api/listings/w1ne--labwired-core/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Clone the repository, install the CLI, run a firmware. No cross-toolchain needed.

git clone https://github.com/w1ne/labwired-core && cd labwired-core
curl -fsSL https://labwired.com/install.sh | LABWIRED_VERSION=v0.25.0 sh
labwired test --script examples/nrf54l15-dk/io-smoke.yaml
nRF54L15 boot OK
core=cortex-m33 rram=1524K ram=256K
uarte20@0x500C6000 gpio2@0x50050400
regs from MDK/SVD, not nRF52
PASS  4/4 checks · io-smoke · 200000 steps · 0.04s

That is a committed bare-metal ELF booting on an nRF54L15-DK profile in under a second. Nothing is compiled on your machine.

The four checks are the three UART lines plus the stop reason.

The firmware prints those lines from string literals. The text proves nothing by itself. What it proves is that the bytes arrived. To send them, the firmware had to boot from RRAM at `0x0`, set up RAM at `0x20000000`, and drive UARTE20 over EasyDMA. Get the UARTE base wrong in the chip model and you get no output at all.

GPIO is checked at the pin, not in the banner, by `firmware_survival::test_nrf54l15_lights_dk_led0`. The [example README](examples/nrf54l15-dk/README.md) says why both tests are needed.

The verdict goes to stderr. The exit code is the gate: `0` passes, anything else fails. UART output and `--json` stay on stdout, so pipes keep working.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 25 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "labwired",
  3. "owner": {
  4. "name": "LabWired",
  5. "url": "https://labwired.com"
  6. },
  7. "plugins": [
  8. {
  9. "name": "labwired",
  10. "source": "./plugins/labwired",
  11. "description": "Design electronic circuits, simulate and verify embedded firmware, and lay out supported PCBs with LabWired.",
  12. "category": "development",
  13. "keywords": [
  14. "electronics",
  15. "circuit",
  16. "firmware",
  17. "pcb",
  18. "embedded",
  19. "arduino",
  20. "esp32",
  21. "kicad"
  22. ]
  23. }
  24. ]
  25. }
README.md · README · 397 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <a href="https://labwired.com">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/w1ne/labwired-core/main/docs/assets/brand/labwired-logo-dark.png">
  4. <img alt="LabWired" src="https://raw.githubusercontent.com/w1ne/labwired-core/main/docs/assets/brand/labwired-logo.png" width="300">
  5. </picture>
  6. </a>
  7. # LabWired Core
  8. Run your firmware on a virtual instance of a real chip, from your terminal, your CI, or your
  9. AI coding agent. No board on your desk.
  10. [![Rust Core CI](https://github.com/w1ne/labwired-core/actions/workflows/core-ci.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-ci.yml)
  11. [![Board CI](https://github.com/w1ne/labwired-core/actions/workflows/core-board-ci.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-board-ci.yml)
  12. [![HW target validation](https://github.com/w1ne/labwired-core/actions/workflows/core-validate-hw-targets.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-validate-hw-targets.yml)
  13. [![Unsupported instruction audit](https://github.com/w1ne/labwired-core/actions/workflows/core-unsupported-audit.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-unsupported-audit.yml)
  14. [![Onboarding smoke](https://github.com/w1ne/labwired-core/actions/workflows/core-onboarding-smoke.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-onboarding-smoke.yml)
  15. [![Arduino matrix](https://github.com/w1ne/labwired-core/actions/workflows/core-arduino-matrix-smoke.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-arduino-matrix-smoke.yml)
  16. [![IO-Link native](https://github.com/w1ne/labwired-core/actions/workflows/core-iolink-native.yml/badge.svg?branch=main)](https://github.com/w1ne/labwired-core/actions/workflows/core-iolink-native.yml)
  17. [![Latest release](https://img.shields.io/github/v/release/w1ne/labwired-core?label=release&color=0b7285)](https://github.com/w1ne/labwired-core/releases/latest)
  18. [![Website](https://img.shields.io/badge/web-labwired.com-0b7285.svg)](https://labwired.com/)
  19. [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://docs.labwired.com/)
  20. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
  21. <img alt="labwired test booting an nRF54L15 and gating on the result" src="https://raw.githubusercontent.com/w1ne/labwired-core/main/docs/assets/labwired-demo.gif" width="100%">
  22. <sub>Recorded from [`docs/assets/demo.tape`](docs/assets/demo.tape) against a real binary. You
  23. can re-run it. The second half breaks an assertion on purpose, so you can see the gate
  24. fail.</sub>
  25. ## What is LabWired Core?
  26. LabWired Core loads a firmware ELF and executes it against modeled silicon: CPU, buses,
  27. peripherals, sensors, displays, and protocol devices. You get UART output, GPIO and bus
  28. traces, register state, and a pass/fail exit code.
  29. Runs are deterministic. The same ELF and the same board manifest give the same trace on
  30. every machine. That is what makes a simulator run usable as a CI gate.
  31. Supported cores:
  32. * ARM Cortex-M0+, Cortex-M3, Cortex-M4, Cortex-M7, Cortex-M33
  33. * RISC-V
  34. * Xtensa LX6 and LX7 (selected ESP32 paths)
  35. This repository is the engine behind [labwired.com](https://labwired.com/). The hosted
  36. browser [Playground](https://app.labwired.com/) and the hosted MCP connector run the same
  37. models. To look before installing anything, open a lab:
  38. [SSD1306 hello](https://app.labwired.com/?lab=ssd1306-hello-lab),
  39. [U575 Star Catcher](https://app.labwired.com/?lab=nucleo-u575-star-catcher&run=1),
  40. [BME280 weather](https://app.labwired.com/?lab=bme280-weather-lab), or
  41. [IO-Link DI/DO](https://app.labwired.com/?lab=iolink-dido).
  42. ## Why use LabWired Core?
  43. Testing firmware on real boards is slow. You wait for hardware, you flash it, and when
  44. something breaks you get a dark LED and no trace. Do that for every board in a product line
  45. and a hardware CI bench stops being worth the upkeep.
  46. LabWired runs the same binary you would flash. You assert on what the firmware made the
  47. hardware do.
  48. Two things separate it from a CPU emulator.
  49. **The board is modeled, not only the chip.** Sensors, displays, and bus devices live in the
  50. system manifest. You can assert on I2C traffic, SPI framing, or what a panel was told to
  51. draw.
  52. **We publish where the model is thin.** Every capability sits in a named tier. Anywhere the
  53. simulator short-circuits real hardware, we write it down in the
  54. [Fidelity Ledger](FIDELITY.md). You cannot gate on a simulator you cannot audit.
  55. ## Quickstart
  56. Clone the repository, install the CLI, run a firmware. No cross-toolchain needed.
  57. ```sh
  58. git clone https://github.com/w1ne/labwired-core && cd labwired-core
  59. curl -fsSL https://labwired.com/install.sh | LABWIRED_VERSION=v0.26.0 sh
  60. labwired test --script examples/nrf54l15-dk/io-smoke.yaml
  61. ```
  62. ```
  63. nRF54L15 boot OK
  64. core=cortex-m33 rram=1524K ram=256K
  65. uarte20@0x500C6000 gpio2@0x50050400
  66. regs from MDK/SVD, not nRF52
  67. PASS 4/4 checks · io-smoke · 200000 steps · 0.04s
  68. ```
  69. That is a committed bare-metal ELF booting on an nRF54L15-DK profile in under a second.
  70. Nothing is compiled on your machine.
  71. The four checks are the three UART lines plus the stop reason.
  72. The firmware prints those lines from string literals. The text proves nothing by itself.
  73. What it proves is that the bytes arrived. To send them, the firmware had to boot from RRAM
  74. at `0x0`, set up RAM at `0x20000000`, and drive UARTE20 over EasyDMA. Get the UARTE base
  75. wrong in the chip model and you get no output at all.
  76. GPIO is checked at the pin, not in the banner, by
  77. `firmware_survival::test_nrf54l15_lights_dk_led0`. The
  78. [example README](examples/nrf54l15-dk/README.md) says why both tests are needed.
  79. The verdict goes to stderr. The exit code is the gate: `0` passes, anything else fails.
  80. UART output and `--json` stay on stdout, so pipes keep working.
  81. ## Installation
  82. The install script covers Linux, macOS, and Windows via WSL2.
  83. ```sh
  84. curl -fsSL https://labwired.com/install.sh | LABWIRED_VERSION=v0.26.0 sh
  85. ```
  86. | Variable | Effect |
  87. | --- | --- |
  88. | `LABWIRED_VERSION=` | pin a release |
  89. | `LABWIRED_INSTALL_DIR=` | choose the install directory |
  90. | `LABWIRED_FROM_SOURCE=1` | build from source instead of downloading |
  91. To read the installer before running it:
  92. ```sh
  93. curl -fsSL https://labwired.com/install.sh -o install.sh # review it, then:
  94. sh install.sh
  95. ```
  96. ### Windows
  97. The native Windows archive contains `labwired.exe` and `labwired-dap.exe`.
  98. Install the current [x64 Microsoft Visual C++ v14 Redistributable](https://aka.ms/vc14/vc_redist.x64.exe)
  99. first; both executables require `VCRUNTIME140.dll`. See Microsoft's
  100. [runtime requirements](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170)
  101. for supported Windows versions.
  102. Download and extract the archive in PowerShell with `tar` available:
  103. ```powershell
  104. $v = "v0.26.0"
  105. Invoke-WebRequest "https://github.com/w1ne/labwired-core/releases/download/$v/labwired-$v-windows-x86_64.tar.gz" -OutFile labwired.tar.gz
  106. mkdir $env:LOCALAPPDATA\LabWired -Force
  107. tar -xzf labwired.tar.gz -C $env:LOCALAPPDATA\LabWired
  108. $env:PATH += ";$env:LOCALAPPDATA\LabWired"
  109. labwired --version
  110. ```
  111. The VS Code extension does this for you on Windows — it downloads the same
  112. archive on first use. WSL2 also works and takes the Linux instructions above.
  113. Or build it yourself:
  114. ```sh
  115. cargo build --release -p labwired-cli
  116. ```
  117. ## Running LabWired
  118. ### From your terminal
  119. ```sh
  120. labwired run --chip configs/chips/<chip>.yaml --firmware path/to/firmware.elf
  121. labwired test --script path/to/test.yaml --junit report.xml
  122. ```
  123. `run` is interactive: UART, GPIO, traces, snapshots.
  124. `test` is the gate. It writes `result.json`, `uart.log`, and JUnit, and returns an exit code.
  125. Assertions cover UART content, memory and register values, stop reasons, and step and
  126. wall-time limits.
  127. See the [CLI reference](docs/cli_reference.md) and the
  128. [test runner reference](docs/ci_test_runner.md).
  129. ### From Python
  130. Install the SDK from PyPI with Python 3.9 or later:
  131. ```sh
  132. python -m pip install 'labwired[test]==0.26.0'
  133. ```
  134. Use `labwired.Sim` to run an ELF, wait for UART output, and write pytest checks:
  135. ```python
  136. from labwired import Sim
  137. with Sim("tests/fixtures/uart-ok-thumbv7m.elf",
  138. chip="ci-fixture-cortex-m3-uart1", uart="uart1") as sim:
  139. sim.expect("OK", timeout="1ms")
  140. ```
  141. The SDK runs the Rust engine in your Python process. See the
  142. [Python SDK quickstart](docs/python-sdk.md) for source-build instructions and a
  143. runnable pytest test using the repository's firmware fixture.
  144. ### In CI
  145. The same YAML scripts are the merge gate, with no HIL bench to maintain:
  146. ```yaml
  147. - run: labwired test --script examples/ci/uart-ok.yaml --junit report.xml
  148. ```
  149. See [CI integration](docs/ci_integration.md) and
  150. [labwired.com/ci](https://labwired.com/ci.html).
  151. ### From an AI coding agent (MCP)
  152. LabWired speaks MCP. An agent can assemble a board, run firmware, and read the result back.
  153. You never touch the toolchain.
  154. ```sh
  155. claude mcp add labwired --transport http https://api.labwired.com/mcp
  156. codex mcp add labwired --url https://api.labwired.com/mcp
  157. ```
  158. Your client opens a browser to sign in on first use. Other MCP clients take the standard
  159. block:
  160. ```json
  161. { "mcpServers": { "labwired": { "type": "http", "url": "https://api.labwired.com/mcp" } } }
  162. ```
  163. Then ask for what you want:
  164. > *"Connect LabWired over MCP. Load a virtual STM32 LED + UART board, run the firmware,
  165. > check the UART output, and give me the Playground URL."*
  166. Agents working inside this repository should read [docs/agents.md](docs/agents.md).
  167. ## How a board is described
  168. A board is data, not code.
  169. A chip descriptor in [`configs/chips`](configs/chips/) declares memory geometry, cores, and
  170. peripheral bases. A system manifest in [`configs/systems`](configs/systems/) wires up pins,
  171. buses, and the devices on them. Firmware writes to modeled registers. The modeled hardware
  172. drives the firmware back.
  173. To add a board you write those two files and an example. You do not patch the engine. See
  174. the [board onboarding playbook](docs/board_onboarding_playbook.md) and the
  175. [configuration reference](docs/configuration_reference.md).
  176. ## What we validate
  177. Every capability sits in one of three tiers, and we say which:
  178. * **Modeled** — simulator logic exists and firmware can execute against it.
  179. * **Smoke-tested** — a committed test or example exercises the model and checks output.
  180. * **Hardware-compared** — captured silicon behavior is diffed against simulator behavior for
  181. a documented scope.
  182. The NUCLEO-H563ZI example is the reference case. The same firmware runs on a physical board
  183. and on the simulator, and the artifacts are committed. See
  184. [`VALIDATION.md`](examples/nucleo-h563zi/VALIDATION.md),
  185. [`determinism_report_h563.json`](examples/nucleo-h563zi/golden-reference/determinism_report_h563.json),
  186. and the [golden reference method](docs/golden_reference.md).
  187. Each report covers the scope it describes. None of them claim that every instruction and
  188. timing path matches silicon. The [Fidelity Ledger](FIDELITY.md) has both sides: where we
  189. short-circuit hardware, and where we hold up. One e-paper panel matches silicon on 19033 of
  190. 19033 SPI transfers.
  191. ## Boards and examples
  192. ARM Cortex-M and RISC-V have the deepest coverage. Some ESP32/Xtensa paths exist for
  193. specific examples. The optional native [QEMU-derived Cortex-A7 backend](docs/qemu-arm-core.md)
  194. runs bounded instruction fixtures through the same CPU and bus interfaces. The
  195. [Luckfox Pico Mini A dossier](docs/boards/luckfox-pico-mini-a.md) includes vendor assets,
  196. pins and declared memory geometry; RV1103 peripherals and Linux boot remain unimplemented.
  197. Check the per-board status before you assume a peripheral is modeled. It is in
  198. [docs/boards](docs/boards/), the
  199. [validation status matrix](https://docs.labwired.com/boards/VALIDATION_STATUS/), and the browsable catalog at
  200. [app.labwired.com/validation](https://app.labwired.com/validation).
  201. | To see | Run |
  202. | --- | --- |
  203. | A deterministic pass/fail gate | [CI UART smoke](examples/ci/README.md) |
  204. | Firmware driving a sensor over I2C | [Blinky + TMP102](examples/demo-blinky/README.md) |
  205. | Simulator compared against a physical board | [NUCLEO-H563ZI](examples/nucleo-h563zi/README.md) |
  206. | CAN/UDS diagnostics | [UDS on STM32H563](examples/h563-uds-ecu/README.md) |
  207. | An IO-Link device | [IO-Link DIDO](examples/iolink-dido/README.md) |
  208. | GDB or VS Code debugging without a probe | [Debugging](docs/debugging.md), [GDB](docs/gdb_integration.md) |
  209. The full list is in [docs/demos.md](docs/demos.md). Each example's README and validation file
  210. is the source of truth for what that example actually models.
  211. ## The LabWired ecosystem
  212. This repository is the engine. Everything below runs on it, and all of it is public.
  213. **Put it in your workflow**
  214. | Project | What it gives you |
  215. | --- | --- |
  216. | [firmware-test](https://github.com/LabWired/firmware-test) | GitHub Action. Run a LabWired test script as a merge gate — no hardware, no cross-toolchain on the runner. |
  217. | [firmware-ci-starter](https://github.com/LabWired/firmware-ci-starter) | Template repo. Firmware, test script, and workflow already wired — [generate](https://github.com/LabWired/firmware-ci-starter/generate) it and your first push runs green. |
  218. | [labwired-zephyr](https://github.com/w1ne/labwired-zephyr) | `west labwired-simulate` on Zephyr 3.7 and 4.5. The optional native runner on 4.5 also supports `west simulate -r labwired` and `west flash -r labwired`; see the setup instructions. |
  219. | [labwired-vscode](https://github.com/w1ne/labwired-vscode) | VS Code extension. Run and debug firmware from the editor without a probe. |
  220. | [labwired-lab-template](https://github.com/w1ne/labwired-lab-template) | Bare template for a repo whose merges gate on a simulation run. |
  221. **Drive it from an agent**
  222. | Project | What it gives you |
  223. | --- | --- |
  224. | [agent](https://github.com/LabWired/agent) | The LabWired Firmware Agent — writes firmware and checks it on a virtual board. |
  225. | [skills](https://github.com/LabWired/skills) | Agent Skills for firmware work against the simulator as a hardware oracle. |
  226. | [`docs/agents.md`](docs/agents.md) | The MCP surface and the rules an agent working in this repo should follow. |
  227. **See it doing real work**
  228. | Project | What it shows |
  229. | --- | --- |
  230. | [labwired-cra-evidence](https://github.com/LabWired/labwired-cra-evidence) | CRA-style secure-boot and signed-OTA evidence, regenerated in CI on a virtual nRF52840 + ATECC608A. Evidence, not a certificate. |
  231. | [smart-ring-digital-twin](https://github.com/w1ne/smart-ring-digital-twin) | An nRF54L15 smart ring, register-level sensor models, and an honest BLE-contention demonstration. |
  232. | [labwired-nokia-ci-demo](https://github.com/w1ne/labwired-nokia-ci-demo) | STM32L476 driving a Nokia 5110 (PCD8544) and an HC-SR04, gated in CI. |
  233. | [labwired-demo-stm32f1xx](https://github.com/w1ne/labwired-demo-stm32f1xx) | Rust `embedded-hal` on STM32F1 under the simulator. |
  234. **Firmware stacks that use LabWired as their test bench**
  235. [iolinki](https://github.com/w1ne/iolinki) (IO-Link device stack for Zephyr) ·
  236. [iolinki-master](https://github.com/w1ne/iolinki-master) (IO-Link master stack) ·
  237. [udslib](https://github.com/w1ne/udslib) (ISO 14229 UDS for embedded ECUs) ·
  238. [thermal-io-link-condition-sensor](https://github.com/w1ne/thermal-io-link-condition-sensor) (MLX90640 + ESP32-C3 condition monitoring)
  239. Using LabWired for something public? [Open an issue][new-issue] and it goes on this list.
  240. ## Missing a chip? Peripheral behaving wrong?
  241. [Open an issue][new-issue] for a wrong register, an unsupported instruction, a board you
  242. need, or a peripheral you would model differently. Attach a firmware ELF and a system
  243. manifest if you can — those usually become regression tests.
  244. Adding a board is the easiest way to contribute: follow the
  245. [board onboarding playbook](docs/board_onboarding_playbook.md), mirror an existing example,
  246. and check the result against the [target support rubric](docs/target_support_rubric.md).
  247. See [ROADMAP.md](ROADMAP.md) for what is planned, [CONTRIBUTING.md](CONTRIBUTING.md) for
  248. repository workflow, and [SECURITY.md](SECURITY.md) for security issues.
  249. [new-issue]: https://github.com/w1ne/labwired-core/issues/new
  250. ## Repository scope
  251. This repository owns the core simulator and its validation assets: CPU, bus, memory,
  252. peripheral, and external device execution; chip and system descriptors; CLI, test runner,
  253. debug adapters, and snapshot/trace tooling; and hardware-target validation metadata.
  254. Application UI, hosted Playground behavior, and product surfaces live outside this package.
  255. The merge gate is [`core-ci.yml`](.github/workflows/core-ci.yml). Narrower signals come from
  256. board smoke coverage ([`core-board-ci.yml`](.github/workflows/core-board-ci.yml)), coverage
  257. ([matrix smoke](.github/workflows/core-coverage-matrix-smoke.yml),
  258. [weekly](.github/workflows/core-coverage-weekly.yml)),
  259. [unsupported instruction audits](.github/workflows/core-unsupported-audit.yml),
  260. [nightly validation](.github/workflows/core-nightly.yml),
  261. [hardware target sweeps](.github/workflows/core-validate-hw-targets.yml), and per-board
  262. throughput ([`core-perf.yml`](.github/workflows/core-perf.yml)). Release mechanics are in
  263. [RELEASE_PROCESS.md](RELEASE_PROCESS.md) and
  264. [RELEASE_READINESS_CHECKLIST.md](RELEASE_READINESS_CHECKLIST.md).
  265. ## Documentation
  266. [Docs index](docs/index.md) ·
  267. [Architecture overview](docs/architecture_overview.md) ·
  268. [Engine architecture](docs/architecture.md) ·
  269. [CLI reference](docs/cli_reference.md) ·
  270. [Python SDK](docs/python-sdk.md) ·
  271. [CI test runner](docs/ci_test_runner.md) ·
  272. [Configuration reference](docs/configuration_reference.md) ·
  273. [Board onboarding playbook](docs/board_onboarding_playbook.md) ·
  274. [Target support rubric](docs/target_support_rubric.md) ·
  275. [Debugging](docs/debugging.md) ·
  276. [PlatformIO integration](docs/platformio_integration.md) ·
  277. [Agents manual](docs/agents.md)
  278. ## Project links
  279. [labwired.com](https://labwired.com/) ·
  280. [Playground](https://app.labwired.com/) ·
  281. [Docs](https://docs.labwired.com/) ·
  282. [Validation](https://app.labwired.com/validation) ·
  283. [For CI](https://labwired.com/ci.html) ·
  284. [Blog](https://labwired.com/blog/) ·
  285. [Pricing](https://labwired.com/pricing.html)
  286. ## Contributing
  287. See [CONTRIBUTING.md](CONTRIBUTING.md) for repository workflow and
  288. [docs/agents.md](docs/agents.md) for AI-agent guidance. For security issues, see
  289. [SECURITY.md](SECURITY.md).
  290. ## License
  291. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.