BENTO · Venture 01
BENTO takes an idea all the way to a model running on a device. It has five parts: firmware on the chip, an IDE for writing applications, a Trainer that builds and tests models, a Store that delivers them and the device that runs them.
What is new
Most parts of BENTO exist somewhere in some form. What we could not find are these combinations, after checking the public documentation and code of comparable tools and stores. If you know of an earlier example, tell us and we will correct this page.
Edge AI Store
It reads the connected board, tells you whether each model will run on it and why not, and installs the model into the board's running MicroPython firmware from the browser, without putting the board into a special mode or reflashing it. We found no other public model store that does this.
BENTO IDE
Built for PSOC™ Edge E84, it shows the same program as a Flow, as Blocks and as Python. The program runs in a MicroPython emulator of the board and then on the real board from the same tab, in Thai and English. We found no other browser IDE that brings these together.
Edge AI Trainer
Every run is checked by release gates (a test set locked against changes, a control run on shuffled labels and a test that the model does not leak who was in its training data) and against the rules the firmware uses to load models. It runs on a self-hosted team server with approvals, in English and Thai, with a signed hand-off to the store. We found no other edge-AI training tool that combines them.
Sources: vendor documentation and public code for model stores and deploy tools for microcontrollers, browser IDEs for MicroPython, and edge AI training tools.
01 · BENTO Secure Firmware
Firmware in three parts on the two Arm® cores of Infineon PSOC™ Edge E84, written in C, with MicroPython for applications. Everything else in BENTO stands on it.
Applications in MicroPython, with an on-screen UI and APIs for the IMU, microphone, radar and environment sensors on the boards that carry them.
On-device inference, offline. Several models come built in, such as motion and sound classes; some of them are published by Infineon and Imagimob under their own terms.
Models arrive from the Edge AI Store at runtime, without a firmware reflash.
Edge AI Creator: the board records IMU or microphone data straight into the Edge AI Trainer over USB. Audio is recorded only with the speaker's consent on the page.
Each current release states which board it is for, so the browser installer offers the right firmware for each board.
Per-board sealed model storage and board identity over mutual TLS on the BENTO HMI Kit, provisioned at delivery.
Secure boot and signed-model verification, switched on in every BENTO device we deliver.
Cortex®-M33 · TrustZone
The first BENTO code to run. It sets up the chip's secure world, and on the BENTO HMI Kit it holds the board's identity and opens sealed models.
Cortex®-M33 · application
Runs the device's logic in MicroPython, its network connections and its model store. On the BENTO HMI Kit it checks each model's signature before handing it to the AI core.
Cortex®-M55 · Ethos™-U55 NPU
Runs several Edge AI models at once on the NPU, alongside the display and the sensors.
Application developers build on top of the firmware in the BENTO IDE, without changing it.
Infineon PSOC™ Edge E84: Arm® Cortex®-M55 and Cortex®-M33 with an Arm® Ethos™-U55 NPU. Toolchain: Infineon ModusToolbox™ and Arm GCC; models compiled for the NPU with Arm Vela.
02 · BENTO IDE
The BENTO IDE is where you write the applications that run on a BENTO device. Build them as a Flow of connected nodes, as Blocks or in Python, test them in an emulator of the board, and then run them on the board over USB.
Three ways to build the same app: Flow, a no-code canvas with live values on the wires; Blocks, mapped one to one to the firmware's modules; and Python with autocomplete, which converts back to Blocks.
The BENTO Emulator runs MicroPython in the browser at the board's own screen size, with a simulated hardware panel, so every idea can be tried before a board arrives.
Connect, run and install applications on the board over USB, straight from the browser.
More than 500 examples, Karel Robot lessons and BENTO Arcade games, and an AI Buddy that answers in Thai or English. About 200 students used it in a single session in September 2026.
03 · BENTO Edge AI Trainer
The Trainer takes raw sensor data to a model that runs on the PSOC™ Edge E84. People stay in charge at every step, and it works in English and Thai.
Six steps: bring in the data, clean and explore it, define classes and labels, train and tune, compile for the NPU, and publish.
Motion (IMU), sound and radar data. Each recording must state its units, axes and sample rate; if any of these is missing, the recording is refused rather than guessed.
Fourteen quality gates that nobody can silently waive. They include a test set that cannot be altered unnoticed, a control run on shuffled labels to show the results are not chance, a minimum detection rate for every class and every group, and a check that the model does not reveal who was in the training data.
Compiled for the Ethos™-U55 NPU and checked against the rules the BENTO firmware uses to load models, before release.
Runs on your own server, with or without a GPU. The creator requests a release and an administrator approves it for the Store.
An on-board test for every model before it reaches the stable channel. Until that test is running, Trainer releases go to the experimental channel. Access is by invitation during the pilot; on-site licences for organisations are being prepared.
04 · BENTO Secure Edge AI Store
Pick a model, check whether it can run on the board in front of you, and send it from the browser without a reflash. You can browse without signing in, in Thai and English.
Board-aware cards: each says only what it knows about your board (running now, ready to deploy, or why not).
Deploy from the Chrome browser over USB, straight from the Store page to the connected board.
My Devices: register a board as yours by its chip ID, then release or transfer it later.
My Scenes and Highlights: several models together on one board, and a timeline of what they recognised.
Sealed to one board: each package is encrypted to that board's own key and carries a one-time ticket (on the BENTO HMI Kit, over USB or an encrypted network link).
Paid per-board licences in the Edge AI Store, opening with online sales.
05 · BENTO Device
The PSOC™ Edge E84 HMI form factor puts radar, an IMU and a microphone behind a screen people want on their wall. Every room uses the same hardware design, with its own scene.
Models run offline on the chip's NPU; results show on the screen.
Highlights carry results (what was recognised and when), not recordings.
Registered to its owner by chip ID in the Edge AI Store.
Current status
We keep live, bench-proven and upcoming work apart, and every line names where it applies.
| Capability | Status | Applies to |
|---|---|---|
| On-device inference, offline | Today | BENTO MicroPython on PSOC™ Edge E84 kits |
| Deploy a model from the browser, no reflash | Today | Edge AI Store, from the browser over USB |
| Record board data into training | Today | Edge AI Creator → Edge AI Trainer (IMU, microphone) |
| Gated training to an NPU-ready model | Today | Edge AI Trainer (pilot, by invitation) |
| Packages sealed to one board, with a one-time ticket | Today | BENTO HMI Kit, over USB from the Edge AI Store or over an encrypted network link |
| Models stored encrypted under a key that belongs to the chip | Today | BENTO HMI Kit |
| Secure boot; signed and sealed models required | Today | Every BENTO device we deliver |
Inference latency, model size and boot time are not published yet; we will publish them when they are measured on named boards.