Lech Kalinowski builds Vault to run local AI agents in your pocket

Modern hardware design pushes constantly toward high-resolution, color-saturated displays that fight endlessly for user attention. Developer and researcher Lech Kalinowski took the opposite path. He designed Vault, a text-first, physical AI handheld terminal built specifically to provide a quiet, distraction-free environment for interacting with large language models.

Vault bypasses the typical notification-heavy interfaces of modern devices. Instead, it relies on a physical keyboard, an encoder wheel, and a custom operating system running on a single microcontroller. This design provides a focused, calm terminal that helps users think, read, and write alongside autonomous agents without the constant noise of modern consumer electronics.

The Dual-Screen E-Paper Solution

Electronic paper offers an ideal reading experience, but its notoriously slow refresh rate makes real-time typing frustrating. Kalinowski solved this UX barrier by combining two entirely different display technologies on a single ESP32 dual-core microcontroller.

The Typing Surface

A small, fast, monochromatic OLED display handles the immediate user input. When you type on the keyboard, characters render instantly on this emissive screen, ensuring zero latency during input.

The Reading Canvas

A second, bistable electronic paper screen acts as the static content viewer. Once you hit enter and trigger a command, the system renders the final model response on the e-paper display. This dual-display configuration yields an energy-efficient terminal that keeps power consumption low while maintaining an incredibly responsive typing experience.

Offloading the Computational Heavy Lifting

Running large generative models directly on pocket-sized microcontrollers remains impossible due to severe memory and compute constraints. To make Vault fully local and private, Kalinowski established a clean division of labor between the device firmware and a high-performance backend.

+---------------+      Wi-Fi      +------------------+      TensorRT-LLM      +-------------------+
| Vault Device  | --------------> |  Python Backend  | ---------------------> | 120B Local Model  |
| (ESP32-S3)    |                 | (Agent Engine)   |                        | (DGX Park GPU)    |
+---------------+                 +------------------+                        +-------------------+

The ESP32-S3 firmware focuses strictly on running a lightweight C++ system. It handles system settings, manages static memory buffers to store one-bit images, and maintains the Wi-Fi connection. The firmware avoids dynamic memory allocation entirely to prevent system crashes on the chip.

The terminal communicates over Wi-Fi with a Python-based backend hosted on an NVIDIA DGX Park. This backend manages the resource-intensive OpenClaw agents and runs an open-source 120-billion-parameter model. Kalinowski optimized the inference performance by serving the model using TensorRT-LLM, translating complex agent thoughts into clean, static structures that the handheld can display easily.

Text-Based Adventures Powered by Enterprise Silicon

Beyond executing server scripts and querying agents, Vault includes a dedicated role-playing game (RPG) mode. The system features four distinct generated settings: a cyberpunk city, a fantasy landscape, a deep-space void, and a classic adventure world.

This text-based console relies on the local 120-billion-parameter model to act as a dynamic game master, tracking narrative states, generating non-player characters, and drawing black-and-white map grids. It presents a striking technical contrast: a silent, low-tech gaming console running a slow-paced text game that secretly consumes the processing power of a cutting-edge enterprise GPU cluster.

Hard Lessons from Custom Prototyping

Building physical hardware from scratch brings inevitable physical failures. Kalinowski went through several design iterations, blowing up two fragile displays during early prototyping before building a robust, custom-regulated power supply to protect the electronic components.

He also solved software I2C conflicts without adding physical pull-up resistors to the board, moved key lines away from failing GPIO pins, and filtered out rotational noise from cheap rotary encoders using hardware capacitors. The resulting device fits into a pocket, runs on a single lithium polymer cell, and stands as a blueprint for offline, private hardware terminals.