# OpenClaw in Your Hand: Building a Physical AI Terminal for Local LLM Agents

Lech Kalinowski

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/akk6KRlcwW4-openclaw-in-your-hand-building-physical-ai) · [Video](https://www.youtube.com/watch?v=akk6KRlcwW4)

## OpenClaw in Your Hand: Building a Physical AI Terminal for Local LLM Agents

A keyboard, OLED and e-paper display make a quiet interface to OpenClaw, while a separate DGX Spark handles inference, agent actions and generated adventures.

Basic familiarity with microcontrollers, LLM inference and agents that can act on a computer is helpful.

### A terminal that answers back

[0:02](https://www.youtube.com/watch?v=akk6KRlcwW4&t=2s)

During a basement cleanup, a dusty device appears in a corner: an old-looking keyboard terminal with unusual displays. Its shell is still running. Type “Who am I?” and it answers in natural language. Lech Kalinowski opens with this imagined discovery, then reveals that it is a possible marketing story. The real ambition is straightforward: build a physical, AI-native device that feels as though it came from the future.

![VAULT title beside a photograph of a gray terminal with a keyboard, display and knob; the presenter holds a device in the inset.](https://ai.engineer/api/talk-essay-media/83a7940a65316eb21d606637b03367f4ce88839bf4b4b9fd23f823e491726224)

Vault’s physical terminal, pictured on the slide and held up by the presenter.

[Kalinowski](https://sessionize.com/lech-kalinowski/), who holds a PhD in physics, spent several months building the device, its backend and the surrounding system. The starting requirement was narrower than the eventual product: a remote controller for an [OpenClaw](https://github.com/openclaw/openclaw/blob/main/docs/gateway/local-models.md) instance on his [DGX Spark](https://www.nvidia.com/en-us/products/workstations/dgx-spark/). That controller became Vault.

### Separate typing from reading

[2:31](https://www.youtube.com/watch?v=akk6KRlcwW4&t=151s)

For this interface, the useful starting point is text: a place to type requests and read model responses. Electronic paper suits sustained reading, but its refresh behavior makes it less suitable for updating the screen with every keystroke. Kalinowski pairs it with a small monochrome OLED, dividing the work between two surfaces instead of asking one display to serve both purposes. The intended benefit is a responsive terminal with economical display power use.

The remote controller also becomes an experiment in an AI-native operating interface built around a microcontroller. Its four modes are shell, assist, control and RPG, as enumerated in the recording’s description. The internal shell handles the terminal’s own settings, basic configuration and Wi-Fi connection; the other modes extend the interface toward assistance, remote actions and play.

In the prototype, the OLED is the **live typing surface**. Entering text updates that display; pressing Enter triggers a render on the bistable e-paper display. This gives the interaction a clear boundary between composing an input and committing a page for reading.

| Surface | Job | Update behavior |
|---|---|---|
| OLED | Live text entry | Updates while typing |
| E-paper | Committed page | Renders after Enter |

The same interface carries requests and responses for LLM interaction and operations on the DGX Spark through OpenClaw.

Making that division practical requires a deliberately small rendering contract. Pages live as **one-bit images in fixed, pre-allocated buffers**. The microcontroller displays those images without a Markdown engine or calls to `malloc`. The page representation is therefore bounded in memory, and the terminal does not need to interpret a rich document format to put a response on screen.

### Power delivery is part of the interface

[7:17](https://www.youtube.com/watch?v=akk6KRlcwW4&t=437s)

The interior is more complicated than a keyboard attached to two screens. Much of that complexity comes from power management: Kalinowski reports destroying two displays during prototyping and needing much more stable current and voltage. A reliable interface depends on keeping its fragile display electronics alive.

The hardware centers on a dual-core ESP32 microcontroller, with the OLED, keyboard, rotary encoder and power-supply components around it. The opened enclosure shows how much wiring and supporting circuitry sits behind the restrained exterior.

![Slide titled “Runs entirely off a single 18650 cell,” with a component table and a photograph of the opened enclosure showing circuit boards and wiring.](https://ai.engineer/api/talk-essay-media/ecaf0507098e54bb4158a7961a8897fc0fc1dfb6fbeb07d1a241c0e010fc881b)

Vault’s component list and internal wiring, powered by a single 18650 cell.

### Keep inference off the handheld

[8:16](https://www.youtube.com/watch?v=akk6KRlcwW4&t=496s)

**Local inference happens on the backend, not inside the terminal.** The compute and power requirements of the LLM would overwhelm the handheld design. Vault firmware runs on the device, while the backend handles both OpenClaw’s agent work and model inference. The terminal is a physical entry point into that system.

For the demonstration, Kalinowski describes an open-source GPT model in the 120-billion-parameter class; the recording’s description identifies it as **gpt-oss:120b**. He serves it using [TensorRT](https://build.nvidia.com/spark/trt-llm), exposing an OpenAI-style interface through an LLM proxy. That adapter matters because other open-source models and serving setups had not matched the API behavior he needed. Current deployment guides describe available serving paths, but do not establish the exact proxy or server configuration used here.

A concrete example is asking the agent to write a Java example and save it on the local machine. Kalinowski reports that OpenClaw, with the model’s help, completed the request. The important transition is from generating an answer to creating a file on the backend host. A small Java artifact for that kind of request could be `Hello.java`:

```java
public class Hello {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : "Vault";
        System.out.println("Hello, " + name + "!");
    }
}
```

The keyboard supplies the request and the displays present the interaction; the agent performs the filesystem action on the machine it controls.

### What failed on the workbench

[10:28](https://www.youtube.com/watch?v=akk6KRlcwW4&t=628s)

The prototype’s field notes are mostly electrical rather than model-related:

- **Software I2C:** The initial wiring did not work correctly. Kalinowski reports eventually controlling the bus without adding physical pull-ups. Treat that as a property of this build, not a general wiring recipe: [Espressif’s I2C guidance](https://docs.espressif.com/projects/esp-idf/en/v4.4.2/esp32s3/api-reference/peripherals/i2c.html) generally recommends external pull-ups because the internal ones are weak.
- **GPIO 13:** A silent failure led him to move the connection to another port.
- **Power regulation:** A regulator damaged the OLED and other fragile display parts. Reworking the power-supply unit was necessary, and replacement parts took a couple of weeks to arrive.
- **Encoder noise:** A cheap rotary encoder produced noisy rotational input. He added pull-ups and capacitors to address it.

These failures explain why the supporting circuitry occupies so much of the hardware design: a clean text interface still depends on clean electrical signals.

### The remote controller becomes an RPG console

[12:08](https://www.youtube.com/watch?v=akk6KRlcwW4&t=728s)

The unexpected fit is a text-based role-playing game. Kalinowski had never played a tabletop RPG with friends gathered around a book and a game master. Building Vault gave him another route into that experience: a dedicated console where an LLM supplies the unfolding fiction.

NPCs, memory and the mood of the world give the game continuity beyond a single generated response. He creates four worlds, drawing on cyberpunk, Witcher-like fantasy with dragons, and a favorite deep-space setting. The text-focused hardware suits an experience in which reading, choosing and imagining are the main activities.

Generation extends to characters, worlds, maps and skills. Pictures then pass through the same rendering constraint introduced earlier: they are converted into one-bit matrices or image maps for the display. The generated fantasy imagery and its physical e-paper output show the two sides of the pipeline—rich material produced upstream, reduced to a representation the terminal can hold and render.

![Slide titled “Narrated on the fly · rendered to paper,” showing five fantasy images followed by a photograph of an e-paper display.](https://ai.engineer/api/talk-essay-media/fc9bf7a0aadbde65e510e77fd49c25dda4c1d3779552b2c98369a37fd3b114c9)

Generated role-playing imagery alongside its physical e-paper output.

### Preserve a usable path—and a quiet environment

[14:42](https://www.youtube.com/watch?v=akk6KRlcwW4&t=882s)

The paired components also provide alternative interaction paths. Kalinowski describes the device as resilient because an individual failure need not make it completely unusable.

| Failure | Remaining path |
|---|---|
| OLED stops working | Read through e-paper |
| Keyboard stops working | Use the encoder |
| Wi-Fi connection fails | Use the local shell |

These paths preserve parts of the experience; the local shell, for example, remains useful without implying that disconnected backend inference continues.

That restrained interaction model is also the product idea. In his intellectual-property research, Kalinowski found much of the attention going toward audio interfaces and video capture. Vault instead makes room for quiet reading, writing, agent work and RPG play without bright moving graphics, advertisements or web browsing competing for attention. He reports pursuing a provisional patent, with the possibility of a commercial device in the future.

### What the build adds up to

[16:25](https://www.youtube.com/watch?v=akk6KRlcwW4&t=985s)

Kalinowski reports 130 commits over roughly three months. His project inventory includes two displays, four modes, four gaming worlds and sixteen classes associated with the RPG system. He describes the firmware as small and fast, without giving a measured size or latency. The handheld uses a single battery cell; the spoken recap calls it lithium-polymer, while the earlier hardware slide labels it an 18650.

The resulting design principles follow directly from those choices: match each display to its job, keep heavyweight LLM inference off the tiny microcontroller, and preserve narrative context in the game rather than tracking only numbers. The display architecture controls the physical experience; the backend carries the computation and the remembered story.

### From boot to a remote disk-space query

[18:03](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1083s)

The recorded demonstration starts with the ordinary operations that make a dedicated device approachable:

1. Boot the terminal and connect to the local Wi-Fi network.
2. Move through the welcome screen to the main interface.
3. Type `help` on the keyboard to display the available commands.

The command reference fills the e-paper screen in multiple columns, showing how the larger reading surface complements the small live display.

![A close-up of Vault’s e-paper screen filled with a multi-column command listing beneath the slide title “Vault, running.”](https://ai.engineer/api/talk-essay-media/7f9d1e3a7a75216cd82c895130307eb925d2094eee0c58b372ff00158c30698c)

The recorded demo shows a multi-column command reference on Vault’s display.

There are separate tutorials for the device and for gaming. The first-use tutorial is optional, so a returning or confident user can proceed directly to the interface. Kalinowski then uses OpenClaw to ask about disk space on the DGX Spark. A response appears in the recording, completing the path from handheld input to inspection of the remote machine and back to the display.

### Choosing an adventure, finding an LLM Game Boy

[20:40](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1240s)

The demonstration then switches to gaming. Four worlds are offered—named in the narration as Alderan, Neon Nabas, The Hollows and Voidreach—followed by character selection. The LLM generates the adventure’s material, including pictures and character personalities. The deep-space scene introduces a breach and a distinctive mood: the terminal is now a window into a generated setting rather than a remote system console.

After the video, Kalinowski points out the amusing contrast: this quiet text game has no three-dimensional graphics, yet the demonstration runs against substantial NVIDIA hardware in a DGX Spark. That is the backend he chose for the demonstration, not a minimum hardware requirement for text RPGs. The computation has moved out of sight, leaving a small device organized around reading and writing.

What began as a handheld controller for OpenClaw and local models has become something closer to a Game Boy for playing with LLMs. Kalinowski closes by crediting Callstack, whose technological incubator supported the work. The change in purpose is the revealing part of the build: once model interaction has a dedicated physical form, operating an agent and inhabiting a generated world can share the same keyboard and paper-like screen.

## Resources

- [Run TensorRT-LLM on DGX Spark](https://build.nvidia.com/spark/trt-llm) — NVIDIA's current deployment playbook includes gpt-oss-120b support and OpenAI-compatible serving on DGX Spark.
- [NVIDIA DGX Spark](https://www.nvidia.com/en-us/products/workstations/dgx-spark/) — Hardware specifications for the compact GB10 Grace Blackwell system used as the terminal's inference backend.
- [OpenClaw local-model configuration](https://github.com/openclaw/openclaw/blob/main/docs/gateway/local-models.md) — Current configuration guidance for connecting OpenClaw to local inference servers and OpenAI-compatible proxies.
- [ESP32-S3 I2C configuration and pull-ups](https://docs.espressif.com/projects/esp-idf/en/v4.4.2/esp32s3/api-reference/peripherals/i2c.html) — Espressif's versioned guide explains I2C configuration, pull-up requirements, and error handling for the ESP32-S3.

## Slides

### One device, four modes

The terminal offers a shell, LLM chat, an autonomous OpenClaw agent, and a text RPG. Typing appears on OLED; long replies appear on e-paper and are paged with a knob.

[4:11](https://www.youtube.com/watch?v=akk6KRlcwW4&t=251s) [Slide describing shell, assistant, control and RPG modes.](https://assets.ai.engineer/sites/aiecode2025/sha256/67d88cb6ba382e7bbab42deb1d2797a1b667282bdd1be57f052ce83b012d3384.webp)

WHAT IT DOES
One device · four modes · one slash command

/SHELL
Bare-metal terminal — local + remote commands.

/ASSIST
LLM chat. Replies render to e-paper.

/CONTROL
Autonomous OpenClaw agent — the agentic mode.

/RPG
LLM-native text RPG · 4 worlds · 16 classes.

Type → OLED. Long replies → e-paper, paged with the knob.

{callstack}

Interface text:
Vault — AI Engineer World's [illegible]
File
[illegible]
Work

### From an LLM reply to a 1-bit page

The broker strips Markdown, caps and paginates replies. Firmware renders the pages in 1 bit, using a 5×7 font and 50% dither, and holds them in pre-allocated buffers.

[6:10](https://www.youtube.com/watch?v=akk6KRlcwW4&t=370s) [Slide explains text preparation, one-bit rendering and static buffers alongside device imagery.](https://assets.ai.engineer/sites/aiecode2025/sha256/afc7a419272ce09408ec98f9402f8b5e7afc8d2a6d6d52a9a243d8c2db9a5041.webp)

THE SURFACES
From an LLM reply to a 1-bit page

▸ Broker shapes the text — strips markdown, caps length, paginates the model's reply server-side.
▸ Firmware renders in 1 bit — one 5×7 font at five scales, a 4-px grid, a 50% dither for the only "tone."
▸ Fixed, static buffers — pages live in pre-allocated memory; no markdown engine, no malloc on the MCU.

Kindle readability · Braun instrument panel · NASA checklist card.

Interface text:
Vault — AI Engineer World's [illegible]
File [illegible]
{callstack}
Work

### AI-native system architecture

Vault firmware sends requests over Wi-Fi to a local backend, which dispatches them to an LLM, OpenClaw agent or RPG engine. The demo runs gpt-oss:120b locally through TensorRT-LLM and a LiteLLM proxy.

[8:15](https://www.youtube.com/watch?v=akk6KRlcwW4&t=495s) [Diagram connects Vault firmware to a local backend, an LLM, an agent and an RPG engine.](https://assets.ai.engineer/sites/aiecode2025/sha256/4f89214df07c867b6cf6347188ddd1d4cf79feae484fcdf2a1f981813b884b94.webp)

AI-NATIVE SYSTEM ARCHITECTURE
AI-native end to end — device, local backend, your models

ON THE METAL
VAULT firmware · ESP32-S3
shell · assist · control · rpg

COMPACT JSON / HTTP OVER WIFI · INFERENCE RUNS ON THE LOCAL BACKEND

DEPENDENCY-FREE PYTHON · PORT 5000
BACKEND — dispatch & guardrails
caps 1500 chars · strips markdown · paginates → fixed buffers · async worker

/CHAT
LLM
gpt-oss:120b on TensorRT-LLM · OpenAI-compatible via LiteLLM

/CLAW
OpenClaw agent
gateway + agents · autonomous tool calls

/RPG
RPG engine
worlds · session · prompts

Demo model: self-hosted gpt-oss:120b served by NVIDIA TensorRT-LLM, exposed OpenAI-style through a LiteLLM proxy — fully local, no cloud.

Interface text:
{callstack}
Vault — AI Engineer World's [illegible]
File /Users/lech.kalinowski/Presentation%20AIEWF2026/Presentation/[illegible]
Work

### Track narrative state, not numbers

The RPG lets NPC memories decay, carries four story hooks forward, and reads the last five moves to infer attitude. World mood colours every scene.

[12:08](https://www.youtube.com/watch?v=akk6KRlcwW4&t=728s) [Slide describes NPC memory, world mood, narrative threads and attitude inference.](https://assets.ai.engineer/sites/aiecode2025/sha256/d90ec8b83720208f24113cb425573ade8d33166285e18101daefc44f9318a6e1.webp)

THE PART THAT SURPRISED ME
Track narrative state, not numbers

IMPERFECT NPC MEMORY
One-line memory that decays — softens at +20, dropped at +40.

WORLD MOOD
calm → tense → ominous → hostile → broken. Colours every scene.

THREADS
4 hooks the world remembers and weaves back in.

ATTITUDE INFERENCE
Reads your last 5 moves — brutal play, harder world.

Don't track HP and dice — an LLM is bad at that. Track what it's great at.

Interface text:
{callstack}
Vault — AI Engineer World's [illegible]
File [illegible]
Work

### Narrated on the fly, rendered to paper

RPG scenes start as prompts to Pollinations.ai, then dithering and 1-bit packing prepare them for an 800×480 e-paper panel. Examples span characters, maps, skills, inventory and quests.

[14:09](https://www.youtube.com/watch?v=akk6KRlcwW4&t=849s) [A row of RPG artwork examples ends with a photograph of an e-paper panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/911e20b06c9f20f5776e3e45815c0009ebb72078522a7d4b54f182786b82821a.webp)

LLM-NATIVE RPG · GENERATED ART ON E-PAPER

Narrated on the fly · rendered to paper

CHARACTER
WORLD MAP
SKILL TREE
INVENTORY
QUEST
ON THE PANEL

Each scene: a prompt → Pollinations.ai → Floyd–Steinberg dither → 1-bit packed for the 800×480 panel.

Interface text:
Vault — AI Engineer World's [illegible]
File /Users/[illegible]/Presentation%20AIEWF2026/Presentation/[illegible]
Work
{callstack}

### Every peripheral is optional

Vault has fallbacks for peripheral failures: serial replaces the OLED, USB input replaces the keyboard, and local commands still work if WiFi fails.

[14:44](https://www.youtube.com/watch?v=akk6KRlcwW4&t=884s) [Table lists fallback behaviors for device peripherals beside a photograph of the device.](https://assets.ai.engineer/sites/aiecode2025/sha256/ba2ae7ae8ba269a7d664212d9e679104f0b6e410f85670396acffaef34774e40.webp)

ROBUSTNESS
Every peripheral is optional

IF THIS DIES... | ...THE DEVICE DOES THIS
OLED | falls back to serial
E-Paper | replies stay [illegible] OLED scrollback
CardKB | type over USB with !<line>
Encoder | keyboard arrows take over
WiFi | local commands still work

Device photograph: VAULT

Interface text:
Vault — AI Engineer World's [illegible]
File /Users/lech.kalinowski/Presentation%20AIEWF2026/Presentation/vault-aie-2026.html
{callstack}
Work

### A brand-new category — with white space

The speaker positions Vault in a quiet-use niche combining e-paper, physical input and a local LLM. The slide says patent probes found zero on-point grants and a provisional was filed.

[15:11](https://www.youtube.com/watch?v=akk6KRlcwW4&t=911s) [Slide describing the intersection of e-paper, physical input, and a local language model in a handheld device.](https://assets.ai.engineer/sites/aiecode2025/sha256/709ffc1c7ee3f09c8d71ec68cfc1ebd0cc0e83fc21da5449f0b9c5049b305638.webp)

WHY IT'S DEFENSIBLE
A brand-new category — with white space

• "LLM + handheld" was effectively zero before 2023.
• Device IP sits in four islands — Echo, Siri, Humane, Rabbit.
• Software claims outnumber hardware ~10:1.

THE VAULT INTERSECTION
Low-power e-paper + physical input + local LLM in a dedicated handheld.

Every probe returned zero on-point grants.

Provisional filed · US deadline 2027-06-09.

Interface text:
Vault — AI Engineer World's [illegible]
File /Users/lech.kalinowski/Presentation%20AIEWF2026/Presentation/vault-aie-2026.html
{callstack}
Work

### Vault, running

The demo shows the handheld’s screen, small illuminated display, knob, and keyboard as the device boots and connects to local Wi-Fi.

[18:19](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1099s) [A handheld device with an e-paper display, small illuminated display, knob, and keyboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/5a673fed0d0964eb2d51a1a92b968584dfd76f1cbf4ee8fc6c8cfde702c9393a.webp)

LIVE DEMO
Vault, running

Device display:
Shell Ready
[illegible]

Click the video to play · keys still navigate slides

Interface text:
{callstack}
Vault — AI Engineer World[illegible]
File /Users/lech.kalinowski/[illegible]
Work

### Device command reference

A help command opens Vault’s on-device reference, grouping commands for modes, the agent, games, networking and settings. The presenter also points out optional device and gaming tutorials.

[19:12](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1152s) [Close-up of the device's e-paper command reference, arranged in sections.](https://assets.ai.engineer/sites/aiecode2025/sha256/45d89263925de263955feba03396b1d659b9359b93effa03e6f5ef3a032ae4c3.webp)

LIVE DEMO
Vault, running

[illegible] REFERENCE [illegible]

SYSTEM
/diag
/status
/devices
/about
/display
/history /h
/clear /cls
/reboot
/home /quit /esc

MODES
/mode shell /shell
/mode assist /assist /ai
/mode control /control /claw
/mode rpg /rpg

AGENT
/agent status
/agent start /agent stop
/oc (= /agent alias)

RPG
/rpg new <world>
/rpg worlds
/rpg saves
/rpg state
/rpg save
/rpg resume [<f>]
/rpg quit

DEMO
/demo rpg
/demo assist
/demo agent
/demo-reset    new user

EPD
/epd test /epd photo
/epd clear /epd sleep
/epd on /epd off
/epd stats /epd force

NAV
/sheet (= /me /char)
/inventory /inv
/quests /skills
/npcs /npc
/threads /thread
ENC PRESS = history

NETWORK
/wifi info
/wifi setup <ssid> <p>
/wifi reset
/backend /host
/model /llm

SETTINGS
/cfg [dt|rt]
/cfg idle <sec>
/cfg reset-dt|reset-rt
/cfg factory
/tutorial device|rpg

[illegible]

Interface text:
{callstack}
Click the video to play · keys still navigate slides
[illegible]

### Disk-space query

The presenter asks the OpenClaw agent to check disk space on a DGX Spark. The device shows the query and a thinking indicator; the result is not yet visible.

[20:00](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1200s) [The device displays a disk-space query and a thinking indicator.](https://assets.ai.engineer/sites/aiecode2025/sha256/39d41bd421c19c95c14e6a5cdff9febe2d9f9e40758f7d8b8d8094561f25ce4d.webp)

LIVE DEMO
Vault, running

Thinking...

QUERY
check disk space

PROGRESS

[illegible]

Interface text:
{callstack}
Click the video to play · keys still navigate slides

### RPG demo commands

The gaming demo lists commands to enter RPG mode, browse worlds, start a cyberpunk game, look around, save and resume.

[20:37](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1237s) [Vault displays a list of commands for an RPG demonstration.](https://assets.ai.engineer/sites/aiecode2025/sha256/8e5b2d9b8451b550e2d5026931831463cbe01fc794e85a781b73127f64832af3.webp)

LIVE DEMO
Vault, running

DEMO: RPG
DEMO: RPG (paste each)
1 /mode rpg
2 /rpg worlds
3 /rpg new cyberpunk
4 look around
5 /rpg save
6 /rpg resume

Interface text:
{callstack}
Click the video to play · keys still navigate slides
File: [illegible]

### Vault RPG demo

In the RPG demo, a player chooses a world and selects a character; the screen shows a Marine of Void Reach. The presenter says an LLM generates the content.

[21:31](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1291s) [Vault displays four RPG world choices, with Elderglen highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/0debfa3d79fce39e1affe9b800506e93f58416f8e589c35afe2f9327ddaa792b.webp)

LIVE DEMO
Vault, running

Pick your world

ELDERGLEN
Forests, kingdoms, dragons.
Magic fades from the land.

NEON ABYSS
Megacorps, chrome, rain.
Trust nobody.

THE HOLLOWS
Wasteland after the fall.
Survival is the only goal.

VOID REACH
Deep space, alien ruins.
Something watches.

[illegible] SELECT  PRESS: NEXT
ESC: BACK
1/2 WORLD

Interface text:
{callstack}
Click the video to play · keys still navigate slides

[21:46](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1306s) [Vault displays a Marine of Void Reach character with an illustration and brief attributes.](https://assets.ai.engineer/sites/aiecode2025/sha256/036c4493f99967659a1f179b094ce3b2c4e6c2fba67a1bf8bba1c1f4ae3ffcac.webp)

LIVE DEMO
Vault, running

MARINE of VOID REACH
[TROOP]  HP +20

Pulse rifle, combat suit.
Holds the line.

ENC TURN: HERO
ENC PRESS: PICK

Interface text:
{callstack}
Click the video to play · keys still navigate slides

### Built and presented by Callstack

Kalinowski thanks Callstack, where he works in the technological incubator, for supporting the project.

[23:15](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1395s) [Callstack closing slide describing its cross-platform and AI work.](https://assets.ai.engineer/sites/aiecode2025/sha256/21b2fd4ad380022504b90c8d1ca73741359e5adb9c0e0dd59e8e27c62bea7451.webp)

BUILT & PRESENTED BY
{callstack}

Ship cross-platform products at AI speed.
React Native core contributors & Meta partners — now building AI-native, with agents.

CALLSTACK.COM
X · @CALLSTACKIO
GITHUB.COM/CALLSTACK

LECH KALINOWSKI, PH.D. · SENIOR AI SYSTEM ENGINEER

Interface text:
{callstack}
File /Users/lech.kalinowski/Presentation%20AIEWF2026/Presentation/vault-aie-2026.html

## Full transcript

[0:02](https://www.youtube.com/watch?v=akk6KRlcwW4&t=2s) Probably all of you once planned the cleanup activities, and you can imagine I also planned one weekend to

[0:11](https://www.youtube.com/watch?v=akk6KRlcwW4&t=11s) cleanup of my basement, and I just, uh, went there, uh, and want to clean up all of the stuff there, you know, throw up, uh, old washing machine. And I just look at the corner there and realize there's something weird there lying on the floor.

[0:34](https://www.youtube.com/watch?v=akk6KRlcwW4&t=34s) So I just grab it, look at the, the strange device, looks a bit familiar, but a bit old, like from '80s, with keyboard, but with a weird displays, of course, covered with dust.

[0:51](https://www.youtube.com/watch?v=akk6KRlcwW4&t=51s) I just take it to my hand, look at it,

[0:56](https://www.youtube.com/watch?v=akk6KRlcwW4&t=56s) and I was completely surprised that, um, device have a shell and it's on.

[1:07](https://www.youtube.com/watch?v=akk6KRlcwW4&t=67s) So, um, I used my superpowers skills in a terminal, and just I provided there a simple question,

[1:20](https://www.youtube.com/watch?v=akk6KRlcwW4&t=80s) "Who am I?" And the device responds in the weirdest way I could even imagine,

[1:28](https://www.youtube.com/watch?v=akk6KRlcwW4&t=88s) in the natural we- language. So the story I just described to you, it can be a great story for a marketing.

[1:40](https://www.youtube.com/watch?v=akk6KRlcwW4&t=100s) But honestly, mmm, I just wanted to build a device which is physical and AI native, like the device which comes from the future.

[1:57](https://www.youtube.com/watch?v=akk6KRlcwW4&t=117s) Hello. My name is Lech Kalinowski. I hold a PhD in physics, and today I want to present you a device and a backend and a system I built over last couple of months.

[2:14](https://www.youtube.com/watch?v=akk6KRlcwW4&t=134s) And the whole story begins because I just simply wanted to build

[2:20](https://www.youtube.com/watch?v=akk6KRlcwW4&t=140s) a remote controller to my OpenClaw instance on my DGX Spark.

[2:31](https://www.youtube.com/watch?v=akk6KRlcwW4&t=151s) And, um, the story is simple because when you are just first think about, uh, LLMs, then you're not thinking about the audio, about the generative, uh, generative, uh, videos or pictures.

[2:50](https://www.youtube.com/watch?v=akk6KRlcwW4&t=170s) First, you're thinking about the text. And then I just get a bright idea that maybe I can use some kind of better display to read and type with my LLM.

[3:06](https://www.youtube.com/watch?v=akk6KRlcwW4&t=186s) F- of course, on the market, there is a electronic paper, but, um, I realized electronic paper can be a bit slow. Of course, it's perfect for reading,

[3:18](https://www.youtube.com/watch?v=akk6KRlcwW4&t=198s) but if you just want to provide dynamically text to it, you probab- probably need a faster display. And then I just, uh, used and, uh, in my design,

[3:33](https://www.youtube.com/watch?v=akk6KRlcwW4&t=213s) uh, a simple connection of a OLED display, the small one, one color,

[3:43](https://www.youtube.com/watch?v=akk6KRlcwW4&t=223s) with the electronic paper display. And then with this simple, let's say, dual display approach, I realized I can build quite a powerful and energy-efficient terminal to

[4:01](https://www.youtube.com/watch?v=akk6KRlcwW4&t=241s) play with my claw. And, um, of course, behind it, uh, there is, uh, some kind of lot of complications because from one side, I just wanted to build a remote control, but from other side, there is such a niche on the market,

[4:26](https://www.youtube.com/watch?v=akk6KRlcwW4&t=266s) and this is the AI-native operational systems. And when I just started to think more clearly about it, I just realized I can build such a system for my purposes, but not with the super powerful co- powerful computers, but with a small microcontrollers.

[4:48](https://www.youtube.com/watch?v=akk6KRlcwW4&t=288s) And I just design a system built in, let's say, with a, uh, with a, say, uh, four classes. One is the internal shell to control the terminal itself, you know, system settings, basic configurations, Wi-Fi connection.

[5:09](https://www.youtube.com/watch?v=akk6KRlcwW4&t=309s) And within my idea to build an AI-native device, I build an assist control and, uh, one thing which really surprised me, and I will explain you later, RPG mode.

[5:28](https://www.youtube.com/watch?v=akk6KRlcwW4&t=328s) And, uh, here it is. I started to prototype DGX Spark at the,

[5:37](https://www.youtube.com/watch?v=akk6KRlcwW4&t=337s) um, at the background here on the picture, two displays. One, it's a live surface. That means the dynamic part. You can type the whole text provided is written there.

[5:54](https://www.youtube.com/watch?v=akk6KRlcwW4&t=354s) And when you are just trigger action, hit Enter, then the whole render also happens on the second bistable electronical paper

[6:09](https://www.youtube.com/watch?v=akk6KRlcwW4&t=369s) But, um, there is a lot of complications and lot of tech and lot of steps you need to do to get an clear user experience and clear interface. So I just found out a lot of the, uh, different approaches how to render properly on the two displays, properly, uh, render the,

[6:34](https://www.youtube.com/watch?v=akk6KRlcwW4&t=394s) the, the, the interface. I just interact to control my LLMs and to get in responses and to do whatever I want with my DGX Spark through the, through the OpenClaw.

[6:45](https://www.youtube.com/watch?v=akk6KRlcwW4&t=405s) And this is the... one of the approaches that you can just

[6:50](https://www.youtube.com/watch?v=akk6KRlcwW4&t=410s) have fixed static buffers and render one-bit images stored in the,

[6:59](https://www.youtube.com/watch?v=akk6KRlcwW4&t=419s) in the memory. That means the pages live in a pre-allocated memory. There's, uh, no markdown engine, uh, and no malloc on the MCU side.

[7:17](https://www.youtube.com/watch?v=akk6KRlcwW4&t=437s) I just wanted really to show you how the system is really complicated here, and this is, uh, not because I just,

[7:27](https://www.youtube.com/watch?v=akk6KRlcwW4&t=447s) uh, wanted to use that much components. It's because there is a huge need to build a, to build a power, um, management system,

[7:39](https://www.youtube.com/watch?v=akk6KRlcwW4&t=459s) uh, because I just blow up two displays over my, uh, prototype build, and, um,

[7:48](https://www.youtube.com/watch?v=akk6KRlcwW4&t=468s) I just, uh, needed to be sure that the current and the voltage is stable as possible. So here inside, you have an MCU, which is ESP32 dual-core microcontroller.

[8:03](https://www.youtube.com/watch?v=akk6KRlcwW4&t=483s) Here you have an OLED display, keyboard, and a encoder, and of course, the mentioned, um, power supply.

[8:16](https://www.youtube.com/watch?v=akk6KRlcwW4&t=496s) But the AI-native end-to-end device is not, uh, let's say that simple because of the, you know, high power consumption and the, and the hunger for the compute capabilities of your device.

[8:32](https://www.youtube.com/watch?v=akk6KRlcwW4&t=512s) So here is a full backend created. That means I just created a full backend, and here's the presented architecture of it, that first we have a Vault firmware deployed on the, uh, on the terminal, and there's a huge backend which, um, handle all of the, um, all of the agentic work with the OpenClaw and handle the LLM.

[8:57](https://www.youtube.com/watch?v=akk6KRlcwW4&t=537s) I just want to point out here, um, within my today's presentation, I just, uh, want to demonstrate you, um, the device connected to, um, uh, open source GPT 120 billion parameters model.

[9:15](https://www.youtube.com/watch?v=akk6KRlcwW4&t=555s) Um, and I just serve that model with the, let's say, most possible optimal way using, uh... And I, I, I use their TensorRT, uh, serving system. And I just exposed OpenAI style, uh, to, uh, also like LLM proxy because I just hit a lot of walls with the other open source models, um,

[9:40](https://www.youtube.com/watch?v=akk6KRlcwW4&t=580s) because that not all models match the style of the OpenAI API.

[9:50](https://www.youtube.com/watch?v=akk6KRlcwW4&t=590s) Um, as I said, uh, the first idea was to build and, mm, play with the OpenClaw through that terminal, and this is the stuff I just do with this.

[10:04](https://www.youtube.com/watch?v=akk6KRlcwW4&t=604s) Here you can look at the picture and see an example. I was po- uh, I was possible, uh, to hit a command, like write a Java example, uh, and store it on my local machine, and OpenClaw with the, with the LLM support just did work and make it happened.

[10:28](https://www.youtube.com/watch?v=akk6KRlcwW4&t=628s) Okay, and here's my field notes, the things that doesn't go as expected. Uh, lessons learned. Uh, first of all, the, uh, software I2C, uh, because I just wired up, uh, things there, and it doesn't work correctly.

[10:48](https://www.youtube.com/watch?v=akk6KRlcwW4&t=648s) Um, and there's a way to, um, to do proper control over, over I2C without any additional physical pull-ups mounted.

[11:01](https://www.youtube.com/watch?v=akk6KRlcwW4&t=661s) From other side, GPIO thirteen, um, there's a silent failure. Uh, there was a need to move to the other port, uh, to, um, to be sure that everything works correctly.

[11:17](https://www.youtube.com/watch?v=akk6KRlcwW4&t=677s) From other side, a need to build up the regulator, the power, mm, supply, um, the whole unit of the power supply, uh, because the, the regulator, uh, kills the OLED and, and fragile parts of the display, and it cost me a lot of time and, and, uh, getting the replacement parts

[11:42](https://www.youtube.com/watch?v=akk6KRlcwW4&t=702s) from the market took so long, a couple of weeks. And the last part, uh, quality of your parts. That means encoder cheap and low quality give me a lot of rotational noise, and there was a need to build up the, the pull-ups and to,

[12:03](https://www.youtube.com/watch?v=akk6KRlcwW4&t=723s) and to, uh, wire it up additional condens-condensators there.

[12:08](https://www.youtube.com/watch?v=akk6KRlcwW4&t=728s) But, uh, this is the funnest stuff. Um, my favorite one

[12:14](https://www.youtube.com/watch?v=akk6KRlcwW4&t=734s) Um, because the, this part really surprised me. Um, you already know there's a huge part called, um, RPG, and behind it is a bit sad maybe story. Um, because, um, I just never played RPG's game, like, on the paper.

[12:32](https://www.youtube.com/watch?v=akk6KRlcwW4&t=752s) That means with a, with a lot of friends, you, you can go to a, uh, to apartment, you know, open a book and make an, uh, someone a g- a game master, uh, and play in a real text-based RPG.

[12:48](https://www.youtube.com/watch?v=akk6KRlcwW4&t=768s) And after a lot of those years, I just never tried it, but I built, um, a RPG game and a console,

[13:00](https://www.youtube.com/watch?v=akk6KRlcwW4&t=780s) um, which give me a pure experience of, uh, text-based, um, RPG games, role-playing games.

[13:09](https://www.youtube.com/watch?v=akk6KRlcwW4&t=789s) And, um, actually, I- it's a bit funny, um, because those device,

[13:17](https://www.youtube.com/watch?v=akk6KRlcwW4&t=797s) it's really, like, perfect fit for that kind of gaming. Uh, uh, I build out an NPC and memory around that. I just created the mood of the world, the contents, omnis, and I just used all of the, you know, the LLM, um, advantages to build, uh, the best, uh, role-play game experience ever.

[13:42](https://www.youtube.com/watch?v=akk6KRlcwW4&t=822s) Um, I just created four different worlds. From one side, I just wanted to build something cyberpunk related. From other side, I just wanted something, uh, The Witcher part related.

[13:53](https://www.youtube.com/watch?v=akk6KRlcwW4&t=833s) That means some kind of fantasy world with dragons. But also my, uh, favorite one is the, is the void in, in a deep space somewhere, um, in the cosmos.

[14:06](https://www.youtube.com/watch?v=akk6KRlcwW4&t=846s) And, uh, this is really, uh, um, really good example how we can just use, uh, generative AI to build, uh, computer games. From one side, I just, uh, generate the characters, their m- worlds, maps, skills, uh, and all of those converted with the mechanics I just described at the beginning of that, uh, presentation with the one

[14:31](https://www.youtube.com/watch?v=akk6KRlcwW4&t=871s) bit, uh, memory allocation. That means all of the pictures transform to the, uh, to the m- matrices, to the, uh, to the, to the maps.

[14:42](https://www.youtube.com/watch?v=akk6KRlcwW4&t=882s) And, um, one, um, important, uh, important thing, actually, uh, the device is really bulletproof. Um, if the OLED doesn't work, you... the E-paper works. If the cardboard doesn't work, that means the keyboard, um, then you, you have an encoder.

[15:04](https://www.youtube.com/watch?v=akk6KRlcwW4&t=904s) Wi-Fi fails, you always can use your, uh, local, uh, shell. Um, and, um,

[15:15](https://www.youtube.com/watch?v=akk6KRlcwW4&t=915s) funny stuff, the area of the intellectual property there. I just, uh, do some kind of research in the field, and everyone just want to build the devices around the audio interfaces, the video capture, you know.

[15:32](https://www.youtube.com/watch?v=akk6KRlcwW4&t=932s) For... But for the quiet places, when you just want to, you know, sit down, keep calm, and play your RPG game, you don't need any of the, you know, colorful, powerful displays, you know, LEDs, you know, popping up with the colors and all of the, uh, distractions, commercials, web pages, and other things.

[15:54](https://www.youtube.com/watch?v=akk6KRlcwW4&t=954s) Sometimes you just want to sit down and, and, you know, do, do the right job with a, with a, with a OpenClaw or, or, or, you know, just chat with your LLM, read and write, uh, in a quiet environment without any of the distractions.

[16:10](https://www.youtube.com/watch?v=akk6KRlcwW4&t=970s) And there's a niche on the market. Uh, so I also decided to build a- the provisional patent here in that field, and maybe it will brings, uh, commercial device in the future to a,

[16:25](https://www.youtube.com/watch?v=akk6KRlcwW4&t=985s) to a market. Some numbers. Mm, in my project, uh,

[16:33](https://www.youtube.com/watch?v=akk6KRlcwW4&t=993s) I just pushed one hundred and th- thirty commits, around three months of work.

[16:41](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1001s) Um, two dip- displays. Each of the display do other job. Four modes, four worlds for gaming. In general, sixteen, um, classes. That means you can generate RPG worlds inside of it.

[16:58](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1018s) Firmware is, is really tiny, really small, and works extremely fast. And, um, everything is powered by one single, uh,

[17:09](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1029s) um, polymer cell, lithium polymer cell. Um, but, uh, maybe

[17:21](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1041s) some remarks, some takeaways. Match the displays to the job.

[17:26](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1046s) Uh, there's a plenty of them on the market. Keep the model off the metal because it's really heavy. That means for now we don't have such a models which runs really on the super tiny MCUs.

[17:39](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1059s) In, it means LLMs. And track a narnative, narrative. The context really matters in LLMs, and in general, not

[17:51](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1071s) numbers. So here I also record, uh, the demo, the usage, how the device work, and some kind of,

[18:03](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1083s) uh, some kind of, um, last, um, last session. Um, please enjoy, and I will place a couple of comments there.

[18:41](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1121s) Device is booting, connecting to a local Wi-Fi network. Here's the welcome screen

[18:50](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1130s) and the main screen. Small display. [keyboard clicking] Keyboard for simple

[19:09](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1149s) help command. Here you have all of the things you can do with the device.

[19:22](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1162s) There's also a tutorial for gaming and tutorial for the device itself. Uh, and when you just switch it on for the first time, then you need to or can go, you, you don't have to, but you can go through the tutorial itself to learn how to use it. [keyboard clicking]

[19:49](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1189s) Usage of the OpenClaw agent. That means right now I'm just checking my DGX Spark

[19:55](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1195s) and want to look at the disk space.

[20:12](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1212s) Here is it. [keyboard clicking]

[20:40](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1240s) Let's maybe now look on the-- my favorite

[20:45](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1245s) part with, uh, gaming.

[21:17](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1277s) Four worlds, Alderan, Neon Nabas, The Hollows, and Voidreach.

[21:44](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1304s) You can select your, mm, your character. And the LLM just generates the stuff.

[22:08](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1328s) Everything is generated there, um, pictures, uh, uh, personalities of the, of the people, and here there's a mood, there's a breach, you're in the deep space and can't

[22:24](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1344s) deep dive into the other world.

[22:50](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1370s) Yeah. So that's it.

[23:12](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1392s) Mm, that was the, the video. Funny part is that, uh, the game like this without the three-dimensional graphics use the most advanced NVIDIA, uh, processor, um, mounted in the DGX Spark.

[23:30](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1410s) That means the, the, the this is the backend currently. I just, uh, prepare for this demonstration. So the quiet game with the, you know, text interface requires the, the most powerful computer, uh, computer graphics card in the, in the world.

[23:50](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1430s) And maybe another thing is that, uh, the presentation was about the handheld device to control, uh, agent and OpenClaw with the local LLMs. But in general, it was about the Game Boy, the device to, to play, uh, with LLMs.

[24:12](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1452s) Thank you for the attention, and thank you very much for the, mm, for the Callstack support because I'm just working at Callstack in the technological incubator, uh, and, uh, the whole work was supported by, by, uh, Callstack company.

[24:32](https://www.youtube.com/watch?v=akk6KRlcwW4&t=1472s) Thank you very much.
