Vault combines a fast OLED display with a bistable e-paper display so it can support typing, live feedback, and persistent reading while using one battery cell.
2
The device keeps inference and agent work on a backend because an ESP32-S3 cannot run the large local model used in the demonstration.
3
A text-first handheld can support shell access, OpenClaw control, assistant interactions, and an LLM-native RPG without the distractions of a conventional screen.
Summary
Lech Kalinowski built Vault as a physical remote control for an OpenClaw instance running on an NVIDIA DGX Spark. The handheld uses an ESP32 dual-core microcontroller, a one-color OLED for dynamic interaction, and bistable e-paper for rendered content. Its firmware handles the device while a dependency-free Python backend dispatches requests to OpenClaw, local models, and the game engine. The demonstration uses an open-source GPT model with 120 billion parameters, served through NVIDIA TensorRT-LLM and exposed through an OpenAI-style API. Kalinowski discusses failures caused by software I2C, a GPIO port, power regulation, and a cheap encoder. The device has four modes, including a text-based RPG that generates worlds, characters, maps, and narrative state. He argues that quiet, text-first hardware has a place for focused work and play, even though the current implementation still needs a powerful computer for inference.
A dual-display terminal fits text interaction better than a single screen
Kalinowski began with the idea of a physical remote control for OpenClaw and focused on text because that is where people first encounter LLMs. E-paper is comfortable for reading but updates slowly, so Vault pairs it with a small one-color OLED. The OLED is the live surface for typing and dynamic text. After the user submits an action, the content is rendered on the bistable e-paper display. This division lets the device provide fast interaction and a persistent reading surface while keeping power use low. The design uses a keyboard and an encoder rather than a conventional graphical interface.
The microcontroller handles the terminal while the backend handles AI work
Vault has four modes: an internal shell for settings, configuration, and Wi-Fi; assist; control; and an RPG mode. The firmware runs on an ESP32 dual-core microcontroller and manages the displays, keyboard, encoder, and power. A separate backend handles agent work with OpenClaw and communication with the LLM. Kalinowski demonstrated the system with an open-source GPT model with 120 billion parameters, served using NVIDIA TensorRT-LLM. He exposed an OpenAI-style interface because other open-source models did not consistently match that API style.
The display pipeline avoids dynamic allocation on the MCU
Kalinowski tested several ways to render the interface across the two displays. One approach uses fixed static buffers and one-bit images stored in pre-allocated memory. The microcontroller side has no Markdown engine and no malloc. This keeps rendering within the small device's limits. The same one-bit memory approach is later used for RPG images, which are converted into matrices and maps. The hardware includes an OLED, an e-paper display, a keyboard, an encoder, an ESP32, and a dedicated power supply.
Power and inexpensive hardware caused the longest debugging sessions
The prototype suffered from unstable current and voltage, and Kalinowski damaged two displays. Software I2C caused problems, while GPIO 13 failed silently and had to be replaced with another port. The regulator damaged LEDs and fragile display parts, and replacement components took a couple of weeks to arrive. A cheap, low-quality encoder produced rotational noise. He added pull-ups and capacitors to make it usable. These failures shaped the design as much as the planned architecture did.
The RPG uses generated narrative state instead of traditional game mechanics
The RPG mode grew from Kalinowski's interest in trying a paper-style role-playing game through the device. He built NPCs and memory around the game, then created four worlds: a cyberpunk setting, a fantasy world related to The Witcher, and a deep-space void among them. The system generates characters, personalities, worlds, maps, and skills. Kalinowski's takeaway is to track narrative context rather than numbers. The game is text-first, yet its generated images still pass through the device's one-bit rendering system.
The device keeps working when individual parts fail
Vault has fallback paths across its hardware and connectivity. If the OLED fails, the e-paper display can still work. If the keyboard fails, the encoder remains available. If Wi-Fi fails, the local shell can still be used. Kalinowski describes this as making the device dependable for its intended use. The architecture does not require every interface to remain available for the terminal to retain a useful function.
Vault targets quiet computing rather than constant visual stimulation
Kalinowski sees a product gap around calm, text-first devices. He contrasts Vault with hardware built around audio interfaces, video capture, colorful displays, advertisements, and web pages. A user may want to sit quietly, work with OpenClaw, or read and write with an LLM. The device is designed for that setting. He filed a provisional patent in the area and suggested that a commercial device might eventually follow, although the talk focuses on the prototype.
The current handheld still depends on a large external computer
The project contains about 130 commits, took around three months, has two displays and four modes, and includes four game worlds across 16 classes. It runs from one lithium-polymer cell, and Kalinowski says the firmware is small and fast. The model does not run on the tiny MCU. During the demo, the quiet text game used the powerful NVIDIA processor in the DGX Spark. That limitation is central to the system: the handheld is portable, but local inference remains on the backend.
"Sometimes you just want to sit down and do the right job with the OpenClaw or just chat with your LLM, read and write in the quiet environment without any of the distractions."15:55
Who should watch
You are building a small hardware interface for agents and need an example of how firmware, displays, and a local model can be split across a device and a backend.
You want to understand the practical costs of building an ESP32 terminal, including display rendering, power regulation, I2C, GPIO, and encoder problems.
You are exploring text-first or low-distraction interfaces for LLMs, especially devices that can expose agent actions without placing inference on the microcontroller.
