The AI software factory for embedded devices.

aperitivo gives AI agents a complete embedded toolchain plus your spec, and lets them build the software for any device with a screen. They test their own work in a browser twin, then the same build runs on the dev board and in production.

Book a demo See how it works

AI writes web apps in minutes. Embedded still takes months.

Thermostats, e-bikes, lab instruments, factory panels, coffee machines: every device with a screen is still built by hand. Agents could do much of the work, but on embedded they're coding blind. They can't run what they write, and nobody sees the real thing until hardware arrives.

>_
Agents can't check their workWithout a way to run and test code off the hardware, AI output on embedded is a guess.
[ ]
Software waits for hardwareProduct and design teams can't try the real interface until boards exist, and every change needs a firmware cycle.
!!
One bug, whole deviceWhen app code shares memory with drivers, a crash on screen can take the whole device down.

Spec & Design in. Working device out.

The factory compiles device software to a WebAssembly container that doesn't care which hardware it's on. That gives agents a closed loop: build, run, check against the spec, fix, repeat. All of it happens before anything is flashed to a board.

  1. 1
    Write the specRequirements, use cases and the signals your hardware exposes. Bring the PDF specs you already have. The spec stays the source of truth.
  2. 2
    Agents build itAI agents write the screens, logic and hardware bindings with full context of the embedded stack and your spec.
  3. 3
    Verify in the twinThe build runs in a browser twin. Agents test it against every requirement, and your team clicks through the real device on day one.
  4. 4
    Ship to the deviceDrop the unchanged container onto the dev board, then into production.
aperitivo — zsh
$ aperitivo build --spec thermostat-t4/spec.md
› reading spec ............ 38 requirements
› agents: screens, logic, bindings
› compiling (ui → wasm)      ok
› binding pipes
    sensor.temperature   → f32
    setpoint.target      ← f32
    schedule.active      ← enum
› testing in twin ...... 36/38 passed
› agents fixing 2 failures   ok
› testing in twin ...... 38/38 passed
› flashing dev board (STM32) ok
$ 
Sample session, for illustration.

What's inside the factory.

A general coding agent knows a bit about everything. The factory gives it what it needs to ship a real device: the right stack, the right context, and a way to prove the result works.

stack/A proven embedded stackA real-time OS for the hardware, a graphics layer for the screen and a WebAssembly runtime for a safe app layer, chosen and wired together for you.
context/Context agents can useAPIs, patterns and constraints of the stack, packaged so agents build the way an experienced embedded team would.
spec/The spec as the mapStart from the whole product and zoom in. Every requirement is traceable to the code and the tests that cover it.
twin/A twin to test againstThe real build, running in a browser with simulated signals, so agents and people can check behaviour without hardware.

One clean line between software and hardware.

The factory builds the app container. You own the C connectors and drivers. In between sits a standard schema of named values, the pipe. Agents build against it, and it's the reason the twin behaves exactly like the device.

Built by the factory App container Screens and logic compiled to WebAssembly and running sandboxed on the device. Generated, tested and updated without touching your firmware.
sensor.temperature◀──f32
motor.speed──▶u16
battery.level◀──u8
mode.selected──▶enum
button.pressed◀──bool
Pink flows to the hardware, cyan flows to the screen.
Owned by you Connectors & drivers Your C code: motors, heaters, sensors, the command bus. Your embedded team keeps full control.

Same container. Three places.

Browser twin

Where agents test their work, and where your team reviews and shares the real device from a link, long before hardware exists.

Dev board

Flash it onto a small MCU and run it against real or simulated signals.

Production

The identical container ships in the device. What you approved is what customers get.

Why WebAssembly on the device?

We first built this architecture inside the HQ of a global appliance maker in 2024. Drivers were in C, and everything on screen ran in a WebAssembly runtime, because a screen should never be able to crash the machine. It also turned out to be exactly what AI agents need: a safe box they can build, run and test on their own.

Crash-safeThe app runs sandboxed. If it fails, the drivers keep running.
Safe for AI-written codeThe runtime manages memory, so generated code can't reach anything it shouldn't.
Hardware-agnosticOne binary for browser, board and product, across chip families.
Independent updatesShip a new app container without reflashing or retesting your drivers.

Any device with a screen.

Home appliances Industrial HMIs E-mobility Medical & lab Smart home Fitness gear Vending & kiosks Automotive accessories

Device makers

Product and design teams get working device software they can change themselves, without waiting for a firmware cycle. Embedded teams stay focused on drivers and hardware.

  • Start from your existing requirements
  • See the whole product, then zoom into detail
  • Keep ownership of everything below the pipe

Microchip makers

Ship your MCU with an AI-ready software factory, so customers get from evaluation board to a working product on your silicon far sooner.

  • Agent-ready support for your dev kits
  • A faster route from evaluation to design win
  • Fits the toolchains your customers already use

Time reclaimed. Let's talk over an aperitivo.

In Italy, aperitivo is the hour between work and dinner. We named the company after it because that's what the factory gives back: the time your team spends hand-building device software, returned to work on the product itself. Tell us about the device you're building next.

Book a demo or write to hello@aperitivo.dev