AI That Runs Your Hardware Lab

AssembleAI designs spec-driven experiments, autonomously runs them on your embedded systems, and delivers verified fixes by controlling your lab instruments.

Firmware and Design Files

Lab Instruments

Device Under Test

AssembleAI autonomously conducts the scientific method on real hardware.

●

Spec-Driven Experimentation

Define what your hardware should do. The AI designs and runs experiments to test it.

●

Real Instrument Control

Directly configures your oscilloscope, power profiler, and logic analyzer. No scripts, no manual setup.

●

Root Cause to Verified Fix

Measures, diagnoses, modifies firmware, and re-measures in a closed loop until the spec passes.

Unit Tests Directly From Engineering Specs

Extracts measurable test cases directly from your engineering requirements, autonomously, with full fidelity.

Spec → Test Generator

Generating

.ers Engineering Requirements

REQ‑01 Active power ≤ 12 mW

REQ‑02 UART response ≤ 5 ms

REQ‑03 TX power ≥ +8 dBm @ 2.4 GHz

REQ‑04 Display brightness ≥ 450 nits

REQ‑05 Speaker SPL ≥ 85 dB @ 30 cm

REQ‑06 USB-C charge current 1.0 A

REQ‑07 Standby battery life ≥ 30 days

REQ‑08 Cold boot ≤ 800 ms

.tests Test Specifications

TC‑01 Active Power Test PASS

TC‑02 UART Latency Test PASS

TC‑03 TX Output Power Test PASS

TC‑04 Display Luminance Test PASS

TC‑05 Acoustic SPL Test PASS

TC‑06 USB-C Charge Test PASS

TC‑07 Standby Battery Test PASS

TC‑08 Cold Boot Time Test PASS

Compiling test cases from requirements…

0 / 8

TESTS GENERATED

SPEC COVERAGE

CONFLICTS

Autonomously creates test cases given an ERS / ERD.

●

Extracts Engineering Requirements at Full Fidelity

Parses your ERS / ERD and captures every measurable spec without losing precision.

●

Automatically Generates Runnable Test Cases

Translates each requirement into a hardware-ready test with pass/fail criteria built in.

●

Fully Editable and Fully Traceable Test Specs

Engineers can edit any test before it runs, and every result traces back to its requirement.

Catch Every Power Regression

Continuously tests every firmware build, identifies every regression, and validates fixes on your hardware in seconds.

Source Measure Unit

Measuring

Regression

Verified

Analyzing

● Measuring Baseline

⚠ Regression Detected: 34× increase

◉ Diagnosing Root Cause

✓ Fixed & Verified

--- μA

AVG CURRENT

---

BATTERY LIFE

Measuring

STATUS

850 μA

AVG CURRENT

11 days

BATTERY LIFE

FAIL

STATUS

10ms Poll

ROOT CAUSE

GPIO IRQ

SUGGESTED FIX

Building

STATUS

27 μA

AVG CURRENT

11 months

BATTERY LIFE

PASS

STATUS

Autonomously validate power draw on every build.

●

Continuous Power Profiling on Real Hardware

An SMU measures current and voltage on every build so regressions surface before they ship.

●

Traces Every Spike Back to Its Root Cause

Cross-references power traces with code diffs and peripheral configs to pinpoint the offending driver.

●

Patches, Reflashes, and Re-Measures

Applies the fix, programs the board, and confirms the build meets your power budget.

Regressions fixed within seconds

Correct Every Timing Issue

Captures waveforms with an oscilloscope in the loop, detects timing violations, and autonomously corrects them on your hardware.

Device Under Test

Oscilloscope — CH1

Capturing

Pulse Width Period Rise Time

---

MEASURED

---

SPEC

Capturing

STATUS

AssembleAI

Orchestrating

Autonomously validate signal timing on every build.

●

Live Waveform Capture from Your Board

Acquires real signals via an oscilloscope to validate rise times, pulse widths, and clock edges after every build.

●

Nanosecond-Precision Timing Checks

Compares every measurement against datasheet specs and flags setup/hold or frequency violations instantly.

●

Fixes Timer Configs and Re-Verifies on Hardware

Adjusts prescalers, clock dividers, or GPIO settings, then rebuilds, reflashes, and re-captures to confirm the fix.

Debug Every Protocol Problem

Captures protocol data with a logic analyzer in the loop, detects communication errors, and autonomously fixes them on your hardware.

Autonomously debug communication protocols.

●

Real-Time Protocol Decode on Live Buses

A logic analyzer captures and decodes I²C, SPI, UART, and CAN traffic straight from your running hardware.

●

Catches Every Bus Error Automatically

Detects ACK/NACK failures, clock-stretching violations, bus contention, and malformed frames automatically.

●

Corrects Configs, Reflashes, and Re-Captures

Fixes baud rates, address assignments, or bus settings, then programs the board and verifies clean transactions.

Device Under Test

Logic Analyzer

AssembleAI

Orchestrating

Autonomous Root Cause and Corrective Action

Debugs and root causes your system and subsystems, then verifies a firmware fix or identifies a hardware change.

Click here for the original NASA.gov paper.

Autonomous RCCA with hardware in the loop.

●

Generates Test Cases from Requirements

Ingests requirements docs and auto-generates verifiable test cases.

●

Verifies Firmware Fixes on Real Hardware

Generates firmware fixes and verifies them with live hardware measurements.

●

Proposes Schematic and Hardware Fixes

For hardware root causes, recommends schematic edits or part changes.

Augment Your Current Development Tools

Integrates seamlessly with the development environment, operating system, and lab equipment your team already uses.

LLM

IDE

Claude

Anthropic

Cursor

AI-First IDE

VS Code

Copilot

Mac

macOS

Windows

Microsoft

test_plan.c unit_tests.c test_config.h

Cursor with AssembleAI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Automated test plan for PCB validation
// Board: IoT-Sensor-v2.1 | Test Suite: Production
#include "test_framework.h"
#include "board_tests.h"
#include "test_logger.h"
typedef struct {
const char *name;
bool (*test_func)(void);
uint32_t timeout_ms;
uint8_t priority;
} test_case_t;
static uint32_t tests_passed = 0;
static uint32_t tests_failed = 0;
test_case_t production_tests[] = {
{"Power Rails", test_power_rails, 1000, 1},
{"Clock Gen", test_clock_gen, 500, 1},
{"I2C Devices", test_i2c_devices, 2000, 2},
{"SPI Comm", test_spi_peripherals, 1500, 2},
{"Temp Sensor", test_temp_sensor, 3000, 3},
{"IMU Cal", test_imu_cal, 5000, 3},
{"GPIO Pins", test_gpio_pins, 1000, 2},
{"UART", test_uart_loopback, 800, 2},
};
void run_all_tests(void) {
for (int i = 0; i < 8; i++) {
execute_test(&production_tests[i]);
}
}

AssembleAI Context Testing

Test Coverage

Test Cases: 12 planned

Coverage: 95%

Duration: 45s

Environment: Production

Test Strategy

Comprehensive test plan for your IoT-Sensor-v2.1 board:

Critical Test Areas:
• Power sequencing - All rails within spec
• Clock generation - HSE, PLL, SYSCLK validation
• I2C peripherals - MPU6050, BME280 communication
• SPI interfaces - MAX31855, ADS1256 functionality
• GPIO states - All pins in correct mode

Test sequence:

// Test Execution Order

run_test("Power Rails");

run_test("Clock Generation");

run_test("I2C Bus");

run_test("SPI Interfaces");

run_test("GPIO States");

Test Resources:

Test Framework Guide Test Case Templates

unit_tests.c • Ln 12, Col 8 • UTF-8 • C

AssembleAI Connected

Works with Your Equipment

Directly interfaces with your oscilloscope, logic analyzer, power profiler, and other tools in your development environment.

Saleae

Tektronix

Keysight

Rohde &
Schwarz

Fluke

Yokogawa

National
Instruments

Joulescope

Don't see your equipment listed? We can integrate with it.

Maximum Security and Privacy

Runs fully on-prem inside your firewall with an air-gapped architecture, so none of your data ever leaves your servers.

Your data never leaves your development environment.

●

On-prem & air-gapped

Runs entirely on your infrastructure. Private cloud, bare-metal server, or isolated workstation.

●

Zero data egress

Schematics, firmware, test logs, and datasheets never leave your network. Not even anonymized telemetry.

●

Full compliance & audit ready

Built for ITAR, EAR, and SOC 2 environments with audit trails, role-based access, and full data sovereignty.

Data never leaves your servers

Runs on your servers

On-premises · Air-gapped

Your Data

Schematics

Firmware

Component datasheets

User guides

Built by Hardware Experts

We have decades of experience working on the Apple iPhone, Google Pixel, Meta Oculus, and Amazon Kindle.

Nima Banai

Co-Founder & CEO

Craig Schindler

Co-Founder & CTO

Google

Get Started Today

Augment your embedded systems team with cutting-edge AI.

Ship hardware 10X faster.

Schedule a Demo

Schedule a call to discuss full integration into your workflow

AI That Runs Your Hardware Lab

AssembleAI designs spec-driven experiments, autonomously runs them on your embedded systems, and delivers verified fixes by controlling your lab instruments.

Firmware and Design Files

Lab Instruments

Device Under Test

AssembleAI autonomously conducts the scientific method on real hardware.

●

Spec-Driven Experimentation

●

Real Instrument Control

●

Root Cause to Verified Fix

Unit Tests Directly From Engineering Specs

Spec → Test Generator

Generating

.ers Requirements

R1 Power ≤ 12 mW

R2 UART ≤ 5 ms

R3 TX ≥ +8 dBm

R4 Lum ≥ 450 nits

R5 SPL ≥ 85 dB

R6 USB-C 1.0 A

R7 Standby ≥ 30 d

R8 Boot ≤ 800 ms

.tests Test Specifications

TC1 Active Power

TC2 UART Latency

TC3 TX Power

TC4 Display Lum.

TC5 Acoustic SPL

TC6 USB-C Charge

TC7 Standby Batt.

TC8 Cold Boot

Compiling test cases…

0 / 8

GENERATED

COVERAGE

CONFLICTS

Autonomously creates test cases given an ERS / ERD.

●

Extracts Engineering Requirements at Full Fidelity

●

Automatically Generates Runnable Test Cases

●

Fully Editable and Fully Traceable Test Specs

Catch Every Power Regression

SMU

                                        ● Measuring Baseline
                                    

                                        ⚠ Regression Detected: 34× increase
                                    

                                        ◉ Diagnosing Root Cause
                                    

                                        ✓ Fixed & Verified
                                    

--- μA

AVG CURRENT

---

BATTERY LIFE

Measuring

STATUS

850 μA

AVG CURRENT

11 days

BATTERY LIFE

FAIL

STATUS

10ms Poll

ROOT CAUSE

GPIO IRQ

SUGGESTED FIX

Building

STATUS

27 μA

AVG CURRENT

11 months

BATTERY LIFE

PASS

STATUS

Autonomously validate power draw on every build.

●

Continuous Power Profiling on Real Hardware

●

Traces Every Spike Back to Its Root Cause

●

Patches, Reflashes, and Re-Measures

Regressions fixed within seconds

Correct Every Timing Issue

Device Under Test

Oscilloscope

Capturing

                            ●
                            Capturing Waveform
                        

---

MEASURED

---

SPEC

Capturing

STATUS

AssembleAI

Orchestrating

Autonomously validate signal timing on every build.

●

Live Waveform Capture from Your Board

●

Nanosecond-Precision Timing Checks

●

Fixes Timer Configs and Re-Verifies on Hardware

Timing violations corrected autonomously

Debug Every Protocol Problem

Device Under Test

Logic Analyzer Capture

AssembleAI

Orchestrating

Autonomously debug communication protocols.

●

Real-Time Protocol Decode on Live Buses

●

Catches Every Bus Error Automatically

●

Corrects Configs, Reflashes, and Re-Captures

Protocol errors corrected autonomously

Autonomous Root Cause and Corrective Action

Debugs and root causes your system and subsystems, then verifies a firmware fix or identifies a hardware change.

Click here for the original NASA.gov paper.

Autonomous RCCA with hardware in the loop.

●

Generates Test Cases from Requirements

●

Verifies Firmware Fixes on Real Hardware

●

Proposes Schematic and Hardware Fixes

Augment Your Current Development Tools

Integrates seamlessly with the development environment, operating system, and lab equipment your team already uses.

LLM:

Claude

Anthropic

Cursor

AI-First IDE

VS Code

Copilot

IDE:

OS:

Mac

macOS

Windows

Microsoft

bringup.c

Cursor with AssembleAI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Hardware bringup sequence
// Board: IoT-Sensor-v2.1
#include "stm32f4xx_hal.h"
#include "board_config.h"
#include "sensors.h"
#include "i2c_util.h"
static uint8_t power_state = 0;
static SPI_HandleTypeDef hspi1;
static I2C_HandleTypeDef hi2c1;
void board_bringup_sequence() {
// Step 1: Configure power rails
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
HAL_Delay(100);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
power_state = 1;
// Step 2: Initialize SPI
hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER;
// Step 3: Initialize I2C
hi2c1.Instance = I2C1;
// Ask AssembleAI...
}

AssembleAI Context Connected

Project Context

Board Version: v2.1

MCU: STM32F407VGT6

Components: 247 loaded

Datasheets: 45 indexed

Intelligent Suggestion

I notice you're bringing up the temperature sensor. Based on your schematic:

MAX31855 Connections (U4):
• PA0 → SO (Pin 3) - MISO
• PA1 → CS (Pin 5) - Chip Select
• PA2 → SCK (Pin 4) - Clock
• R12: 10kΩ pull-up on SO

Initialization sequence:

// MAX31855 Initialization

SPI_HandleTypeDef hspi1;

MAX31855_Init(&hspi1, GPIOA, 1);

HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, SET);

// CS high initially

HAL_Delay(200); // Startup time

Works with Your Equipment

Saleae

Tektronix

Keysight

Rohde &
Schwarz

Fluke

Yokogawa

National
Instruments

Joulescope

Don't see your equipment listed? We can integrate with it.

Maximum Security and Privacy

Runs on your servers

On-premises · Air-gapped

Your Data

Schematics

Firmware

Component datasheets

Data never leaves your servers

Your data never leaves your development environment.

●

On-prem & air-gapped

●

Zero data egress

●

Full compliance & audit ready

Built by Hardware Experts

Nima Banai

Co-Founder & CEO

Craig Schindler

Co-Founder & CTO

Google

Get Started Today

Ship hardware 10X faster.

Schedule a Demo

Schedule a call to discuss full integration