Stack-Chan Minimal: Tiny Body, Local AI Soul

Stack-Chan Minimal — Tiny Body. Local AI Soul.

What is Stack-Chan Minimal?

Stack-Chan Minimal is a keychain-sized AI companion robot built around the M5Stack AtomS3R.

Instead of trying to run a large AI model inside the tiny robot itself, Stack-Chan Minimal separates the body from the AI brain.

The AtomS3R becomes the robot's face and physical interface, while speech recognition, an LLM, and text-to-speech can run locally on a PC, Android device, or another compatible host.

The result is a tiny robot that can listen, think, speak, display expressions, and optionally move — while letting users see and experiment with the individual parts of a modern conversational AI system.

Tiny Body. Local AI Soul.

Why I built it

Modern generative AI is extremely powerful, but most people experience it through a browser or smartphone app.

You type or speak something, and an answer appears.

What happens between those two points is often invisible.

I wanted to create something that makes this process easier to understand.

Stack-Chan Minimal turns a conversational AI pipeline into a small physical robot:

Voice → Speech-to-Text → LLM → Text-to-Speech → Robot

By separating these functions, users can experiment with each component independently.

Change the speech recognition engine.Change the local LLM.Change the voice.Change the robot's behavior.

The physical robot can stay the same while the intelligence behind it evolves.

That is the main idea behind Stack-Chan Minimal:

It is not tied to one AI model. It gives the AI you choose a small physical body.

How does it work?

Stack-Chan Minimal divides the system into two roles: a tiny physical robot and a replaceable local AI backend.

On the robot side, the M5Stack AtomS3R provides the face, control logic, and Wi-Fi communication, while the Atomic Voice Base provides the microphone and speaker interface.

On the AI side, a host device such as a PC or Android device handles the heavier processing: speech recognition, local LLM inference, and text-to-speech.

For speech recognition, Stack-Chan Minimal can connect to whisper.cpp.

For conversation, it uses an OpenAI-compatible API, allowing local LLM servers such as llama.cpp or Ollama to be used.

For speech output, it connects to an external TTS server such as piper-plus.

The firmware does not bundle the AI models themselves. Instead, each AI service runs separately and can be replaced independently.

This modular design keeps the physical robot small while allowing the AI backend to evolve.

The robot does not have to change when the AI changes.

Why M5Stack AtomS3R?

The AtomS3R is not simply a controller hidden inside the case.

It becomes the visible identity of the AI.

Its small display gives Stack-Chan a face, while the Atomic Voice Base provides the audio interface needed for natural voice interaction.

Wi-Fi connects this tiny physical body to local AI services running on another device.

This creates a clear division of roles:

AtomS3R = Body

Local AI backend = Soul

Voice, expressions and motion = Personality

This approach allows a very small ESP32-based device to interact with AI models that are far larger than anything that could run directly inside the robot.

The physical body can remain small, simple and familiar while the intelligence behind it continues to improve.

Minimal hardware, expandable intelligence

The name “Minimal” reflects the design philosophy.

The robot side is intentionally kept compact.

The core hardware is based on the M5Stack AtomS3R AI Chatbot Kit, combining the AtomS3R with an audio interface, together with a 3D-printed Stack-Chan body.

The basic idea is to avoid putting unnecessary computing hardware inside the robot.

Instead, more demanding AI processing is moved to a PC or another compatible local host.

This gives Stack-Chan Minimal two advantages:

• The robot itself can remain extremely small.
• The AI can be upgraded without rebuilding the robot.

A newer LLM, a different speech recognizer, or a different voice can be introduced without changing the basic hardware.

Small body. Replaceable intelligence.

Easy to configure and reproduce

Stack-Chan Minimal is intended not only as a finished robot, but also as a Maker project that others can reproduce and modify.

The firmware includes a Wi-Fi configuration portal, allowing network and server settings to be configured without hard-coding them into the firmware. The public project is also structured as a PlatformIO project, and the repository contains source code, documentation, and 3D case files.

This is important because the goal is not to create a one-off demonstration.

I want users to be able to build their own Stack-Chan Minimal, connect it to their own local AI environment, and then modify it.

Different users may choose different:

• local LLMs
• speech recognition models
• TTS voices
• character personalities
• servo motions
• physical cases

The same small robot can therefore become many different AI companions.

Local-first and modular

Stack-Chan Minimal is designed around local AI services rather than a single proprietary cloud service.

The current public firmware supports:

• whisper.cpp for speech-to-text
• OpenAI-compatible local LLM servers, such as llama.cpp or Ollama
• External TTS servers such as piper-plus
• Optional VOICEVOX-compatible TTS integration

The AI models, server binaries and voice models are intentionally not included in the firmware repository. Users install and operate compatible services separately.

This keeps the robot independent from any single AI model or vendor.

If a better local model appears, the robot can use it.

If a user prefers a different voice, the voice can be changed.

If the AI computer is upgraded, the physical robot does not become obsolete.

This is why I think of Stack-Chan Minimal as an interface for local AI, rather than simply a chatbot.

Learning AI through a physical robot

Another goal of Stack-Chan Minimal is education.

When people use a normal AI assistant, the entire process often appears as one black box.

Stack-Chan Minimal makes the individual steps visible:

1. Hear the userThe microphone captures speech.

2. Convert speech into textSpeech-to-text recognizes what was said.

3. Generate a responseThe local LLM decides how to answer.

4. Convert text back into voiceText-to-speech generates audio.

5. Give the AI a physical presenceThe AtomS3R shows expressions, plays the voice, and can optionally move.

Each stage can be changed independently.

This makes it possible to learn not only how to use an AI assistant, but also how the different technologies inside one actually work together.

That is why Stack-Chan Minimal is intended for demonstration, learning, and Maker activities.

Optional motion and sensors

Stack-Chan Minimal can also be expanded beyond conversation.

The current public firmware includes optional servo motion, allowing the robot to add physical expression to its responses.

It also includes support for a MAX30100 sensor module for heart-rate and SpO2-like reference-value demonstrations. These values are intended only for demonstration and educational use and are not medical measurements.

These optional functions demonstrate another part of the concept:

A local AI does not have to remain only a voice or text interface.

It can receive information from physical sensors and express its responses through a physical body.

What makes Stack-Chan Minimal different?

There are already many AI chatbot projects.

My goal was not simply to add a chatbot to a small display.

The key idea is the separation of embodiment and intelligence.

The M5Stack device provides the physical presence.

The host device provides the replaceable intelligence.

That separation makes the project:

• small
• modular
• upgradeable
• understandable
• suitable for experimentation

The AI may change every few months.

The little robot does not have to.

Change the model, not the robot.

Open source

Stack-Chan Minimal is released as an open-source project under the Apache License 2.0.

The repository includes the firmware source code, PlatformIO project files, documentation, and hardware case files. Third-party licenses are also documented separately.

Source code:https://github.com/A-Uta/StackChan_Minimal

The project page and additional information are also available on ProtoPedia:

https://protopedia.net/prototype/8374

My hope is that other Makers will build their own versions, connect different local AI models, create new bodies and behaviors, and continue experimenting with what a small physical AI companion can become.

Tiny Body. Local AI Soul.

AI models will continue to become more powerful.

But I do not think every AI needs a large physical machine around it.

Sometimes, all that intelligence needs is a tiny face, a voice, and a body small enough to carry with you.

Stack-Chan Minimal is my attempt to give local AI that physical presence.

Tiny Body. Local AI Soul.