Open source · Self-hostable

Ship voice AI hardwarein an afternoon.

Vibbo gives developers the whole loop: firmware for ESP32-class boards, a documented device protocol, and a console where you swap models, voices, and tools without rebuilding the audio pipeline.

Start building free View on GitHub

MIT licensed · Self-host it or use the hosted console · No credit card

ESP32-S3 / C3 / P4
WebSocket + MQTT
MCP tool calls
OTA updates

Agent profileDevice online

Model: Any OpenAI-compatible
Voice: Nova · warm
Persona: Workshop guide
Tools: Home · Weather

Live session

Dim the living room lights a little.

Done — the living room is at 30%. Want me to keep it there tonight?

End to end ~600ms

Quickstart

From a bare board to a talking device in four steps.

No audio pipeline to build and no protocol to reverse engineer. Flash, pair, configure, talk.

1
Flash the firmware
Use the prebuilt firmware for ESP32-S3, C3, or P4 — or compile your own from source.
2
Pair the device
The board joins Wi-Fi and shows a six-digit code. Enter it in the console to bind it to your account.
3
Configure the agent
Pick the language model, speech provider, voice, and persona. Changes apply on the next turn.
4
Start talking
Wake the device and speak. Every session, tool call, and transcript stays inspectable.

vibbo-cli

$ vibbo device pair --code 482913
  board      esp32-s3
  transport  websocket
  agent      workshop-guide
  status     paired

$ vibbo session tail
  wake     "hey vibbo"
  asr      "dim the living room lights"
  tool     home.set_brightness(30)
  tts      nova · 612ms

Capabilities

Everything the voice loop needs, already wired.

Vibbo runs streaming speech recognition, the model, and synthesis as one low-latency loop, and exposes every part of it as configuration.

Real-time voice conversation

Streaming ASR → LLM → TTS with offline wake word and barge-in, tuned for sub-second replies.

Switch voices in one click

Change the speech provider, voice, speed, and language per agent — no firmware rebuild.

Model agnostic

Point an agent at any OpenAI-compatible model or provider, and swap it whenever your needs change.

MCP tool calls

Give the agent real actions: drive peripherals on the device, or reach smart home and search in the cloud.

Device and OTA management

Observable sessions

Read the transcripts, timings, and tool calls behind every single response.

System architecture

One path from microphone to model.

Every layer is replaceable. Take the whole stack, or bring your own hardware and keep the server.

Hardware

MCU + microphone + speaker + display

Firmware

Wake word, audio codec, connectivity

Protocol

WebSocket / MQTT / MCP

Server

LLM + ASR + TTS + memory + tools

Open by default

Own the stack you ship on.

The device protocol, the server, and the console are yours to run, read, and extend.

View on GitHub

Documented device protocol

Bring any board that speaks the WebSocket device loop.

No vendor lock-in

Mix model, speech, memory, and tool providers per agent.

Self-hostable server

Run the whole stack on your own infrastructure with Docker.

Traceable end to end

Read the source, trace the session, patch what you need.

Ready when you are

Build your first talking device today.

Create an agent, pick a voice, pair a board — the console walks you through every step.