iri Notes

Note

labcast-ai-debugger-PRD

◈ Obsidian Startup March 17, 2026

LabCast — AI-Assisted Remote Hardware Debugger

"SSH into your hardware from anywhere, with AI that watches the debug session and tells you what's wrong."

The Problem

Embedded engineers have to be physically present to debug hardware. This means:

  • Flying/driving to labs to attach a JTAG cable
  • Blocking a full day for what might be a 20-minute fix
  • Long-distance teams can't collaborate on hardware in real time
  • Hardware startups pay for office space just to have a lab engineers must visit
  • Nvidia, Qualcomm, Apple — engineers go to the office specifically to debug boards

Hosung lived this. 3 years at Nvidia, going to the office not for meetings — but to attach a cable.

Post-COVID, remote work is expected everywhere except hardware. That gap is the product.

The Solution

A small box (Raspberry Pi running LabCast software) sits next to the target hardware in the lab. Engineers connect to it from anywhere via browser or VS Code. They get a full, live debug session — JTAG, GDB, serial output, power profiling — as if they were sitting in the lab.

The AI layer watches the session and actively assists: reading crash dumps, analyzing power anomalies, suggesting fixes, explaining register states.

How It Works

Hardware (v1 — no custom manufacturing)

  • Customer buys a Raspberry Pi 5 (~$80) + JTAG adapter (J-Link or CMSIS-DAP, ~$20-400)
  • Installs LabCast software (one command)
  • Plugs into target device
  • Done — lab is now remote-accessible

Software Architecture

┌─────────────────────────────────────┐
│         Engineer (anywhere)         │
│   Browser / VS Code Extension       │
└──────────────┬──────────────────────┘
               │ encrypted WebSocket tunnel
┌──────────────▼──────────────────────┐
│         LabCast Cloud               │
│   Auth, session routing, AI layer   │
└──────────────┬──────────────────────┘
               │ persistent tunnel (WireGuard)
┌──────────────▼──────────────────────┐
│         LabCast Box (Pi in lab)     │
│                                     │
│  ┌─────────────────────────────┐   │
│  │ OpenOCD (JTAG/SWD server)   │   │
│  │ GDB server                  │   │
│  │ Serial monitor              │   │
│  │ Power profiling (INA219)    │   │
│  │ AI debug agent              │   │
│  └──────────────┬──────────────┘   │
└─────────────────┼───────────────────┘
                  │ JTAG / SWD / UART
┌─────────────────▼───────────────────┐
│      Target Device (any MCU/SoC)    │
│  STM32, ESP32, RP2040, custom SoC   │
└─────────────────────────────────────┘

What the Engineer Sees

Left panel: Live GDB session — set breakpoints, step through code, inspect registers, all in browser Right panel: Real-time power draw graph (mA over time), serial output stream Bottom panel: AI assistant

[AI] Detected hard fault at 0x08003A2C
     Stack trace points to dma_transfer() → line 247 dma_init.c
     
     Cause: DMA transfer completed (DMA_FLAG_TC set) before 
     destination buffer initialized. Race condition.
     
     Fix: Move DMA_Init() after buffer allocation on line 231.
     Want me to show the diff?

[Engineer] yes

[AI] Here's the change:
     - DMA_Init(&hdma, &config);
     + // moved below buffer init
       buf = malloc(DMA_BUF_SIZE);
     + DMA_Init(&hdma, &config);

AI Layer — What It Does

The AI doesn't just answer questions. It actively watches the debug session.

Trigger AI action
Hard fault / crash Reads stack trace, identifies root cause, suggests fix
Power spike Flags anomaly, correlates with code execution point
Breakpoint hit Explains current register state in plain English
Watchdog reset Traces which task exceeded time budget
Memory fault Identifies buffer overflow / null pointer source
Engineer pastes error Searches similar issues across session history

The moat: The AI has context that cloud coding assistants don't — live register states, real power data, the actual hardware behavior. It's not guessing from code alone. It sees what the hardware is actually doing.

Target Users

Primary: Embedded engineer at a hardware startup

  • 2-50 person company shipping a hardware product
  • Has a lab with dev boards, may not be co-located with the lab
  • Pain: blocked on hardware debug, can't work from home
  • Budget authority: yes (or easy yes from CTO)

Secondary: Hardware team at a larger company

  • Team distributed across offices or remote
  • Currently uses shared lab access with scheduling friction
  • Pain: coordination overhead, travel cost, lost engineering time
  • Budget: easier — company pays, not individual

Not yet: Hobbyist / maker

  • Pain exists but willingness to pay is low
  • V2 or open source tier

Competitors

Product What it does Gap
JLink Remote Server Tunnels JTAG over network CLI-only, no UI, no AI, painful setup
OpenOCD Open source JTAG server Local only, no remote, no AI
Lauterbach TRACE32 Professional debug tool $10k+, no remote, no AI layer
Serial terminal apps Serial only JTAG/SWD not supported
TeamViewer / VNC Screen share the debug machine Latency, requires physical setup, no AI

Nobody has: browser-based remote JTAG + AI-assisted debug + power profiling in one product.

Revenue Model

Pricing

Tier Price What's included
Indie $49/mo 1 box, 1 user, basic AI
Team $199/mo 5 boxes, 5 users, full AI, session recording
Pro $499/mo Unlimited boxes, team collaboration, priority support
Enterprise Custom On-prem option, SSO, audit logs, SLA

Hardware (optional, V2+)

  • Sell a pre-configured LabCast Box ($149 one-time) — Pi with software pre-installed, plug and play
  • Margins thin but reduces friction to adoption

Build Plan

V1 — Prototype (Month 1, Hosung solo)

  • OpenOCD running on Pi, exposed via WebSocket tunnel
  • Basic web UI: GDB terminal + serial output
  • No AI yet
  • Tested on: STM32 + ESP32 (most common targets)
  • Goal: Hosung can debug his own Nvidia-era test boards from home

V2 — Private Beta (Month 2-3)

  • Add power profiling (INA219 sensor, ~$3)
  • Add AI layer: feed GDB output + register state to Claude API, get debug suggestions
  • VS Code extension (connects to same tunnel)
  • 5 beta users from Hosung's Nvidia network

V3 — Launch (Month 4-5)

  • Auth, team management, billing
  • Session recording + playback
  • AI trained on common MCU fault patterns (STM32, ESP32, RP2040)
  • HN launch: "We built remote JTAG debugging with AI — because embedded engineers shouldn't have to go to the office to attach a cable"

Open Source Strategy

OSS (the thing that gets stars):

  • The Pi agent software (what runs on the box)
  • Basic local tunnel (single user, no cloud)
  • OpenOCD wrapper + serial monitor

Paid cloud:

  • Secure multi-user tunnel (the hard part)
  • AI debug assistant
  • Session recording
  • Team collaboration
  • Pre-built LabCast Box hardware

OSS gets adoption from the embedded community. Cloud converts teams who need multi-user + AI.

YC Application Angle

The story:

"Embedded engineers spend 20% of their time physically present in labs just to attach debug cables. We built remote JTAG debugging with an AI layer that reads register states, crash dumps, and power profiles in real time and tells you what's wrong. Hosung spent 3 years at Nvidia going to the office for exactly this reason. We're the first product that makes hardware debugging fully remote."

Why now:

  • Remote work expectation is permanent post-COVID — even hardware teams
  • LLMs are finally good enough to reason about low-level hardware state
  • Edge AI explosion means more hardware with complex firmware being shipped by smaller teams

Traction path:

  • Hosung's Nvidia network = 5 beta users immediately
  • Embedded community (r/embedded, HN, EEVblog) = organic distribution
  • OSS launch = stars + inbound from hardware companies

What Angie Builds

  • The web UI (GDB terminal, power graph, serial panel)
  • AI chat interface
  • Dashboard: session history, team management, billing
  • Landing page + launch assets
  • Customer discovery + onboarding

What Hosung Builds

  • Pi agent software (C++ / Python)
  • OpenOCD integration
  • WebSocket tunnel
  • Power profiling integration
  • AI context pipeline (feeding hardware state to LLM)

Open Questions

  • Which JTAG adapters to support first? (J-Link is standard but expensive; CMSIS-DAP is cheap and open)
  • Self-hosted tunnel (WireGuard) vs. managed cloud relay — which for v1?
  • How does the AI layer handle proprietary chip architectures (custom SoCs at big companies)?
  • Does Hosung want to talk to 5 embedded engineer friends this week to validate?

Written 2026-03-17 — separated from original LabCast PRD Original PRD: Startup/remote-hardware-debug-lab-PRD.md