iotta — Product Overview

Customer-facing positioning. For the engineering vision see design.md; for the commercialization model see commercialization.md.

iotta is the self-hosted server that turns an embedded device into a voice assistant — and the workshop where your team builds, tests, and ships that assistant, from the first simulated prototype to a fleet in the field.

Who it's for

Hardware / firmware teams — a faithful device protocol, a software device to test against, and safe updates from the same server.
AI / application teams — versioned prompts and actions, full session records, and automated testing.
Whoever has to run it — one container, one command, one backup file.

What it does

The live assistant

Runs the real-time voice conversation, and lets the user cut in mid-sentence.
Speech-to-text, the AI model, and text-to-speech are each swappable — use OpenAI, an OpenAI-compatible service, or models on your own hardware, all by changing config.
Two ways to build the voice, one setup. Wire it up as separate steps (speech-to-text → AI model → text-to-speech, so you can swap or self-host each piece), or use a single all-in-one speech model (faster, fewer moving parts). The device and every tool work the same either way, so you can compare the two head-to-head.
The AI can trigger device actions — read a sensor, set the volume, light an LED — over a separate, dedicated channel.

Building and testing

Software device — a stand-in for the real hardware, so you build and test the whole experience before any hardware exists.
Browser simulator — run a real session from your browser, no install: watch the messages and audio flow, trigger the AI's device actions and see their results and errors, and catch connection problems as they happen. Save any session as a repeatable test.
Audio capture for tuning — grab the device's raw, uncompressed audio (not just the compressed stream) to tune speech recognition and audio hardware, switch a running device into that high-fidelity mode on the fly, and replay any turn's audio right in its record.
Session records + replay — every session, live or simulated, is saved as a detailed, searchable record you can replay against a different prompt, model, or speech engine to see what changes.
Automated testing — write scripted test conversations, score them automatically against expected results, and run the same tests against either setup (separate steps or all-in-one) — catching regressions before they go live.
Versioned prompts and actions — prompts and the AI's device-action definitions are saved as versions that move through draft → staged → live; going live is a deliberate step, never an accidental overwrite.

Managing the fleet

A live roster of your devices showing who's actually online right now — from real connections, not a stale check-in.
Bring devices online in groups, each with its own enrollment rules and default assistant setup.
Safe updates over the air — each firmware build is fixed and checksummed; roll it out to a slice of the fleet first, hold back devices too old to take it, undo a release with one command, and let iotta automatically pull a build that starts crashing devices.

Seeing what's happening

Per-turn and per-session numbers — tokens used, time to the first response, how long each step took, and the timing of any back-and-forth with device actions — all captured automatically.
A full record of each session: step timings, the AI's device actions, and inline audio playback.
Device health over time, plus the crash rate of each firmware version across the fleet.
Outside-AI-call inspector — for every call to an external AI service: the request and response, how long it took, tokens, an estimated cost, and any errors.
Logs and metrics export to the standard monitoring tools you already use.

Running the server

One container with a built-in database; all its data is plain files on the host.
A one-command checkup of storage, disk space, security settings, and provider keys.
Back up everything to a single file — and restore it just as easily.
A system-status page in the UI, with HTTPS handled for you by a bundled proxy.

The web console

Every admin task is doable in the browser.
The platform serves the console itself — nothing extra to install.

Why iotta

Ship faster. One platform from day-one simulation through prototype to production — no separate test tools, nothing to re-wire between stages.
Teams work in parallel. AI and firmware share one agreed list of device actions, so neither side waits on the other.
See everything. Every session, every device's health, and every outside AI call — timing, tokens, cost, errors — logged and browsable.
Simple to run. One container on a small box, no extra databases or services to babysit, HTTPS on by default, backups in one file.
Yours to own. Self-hosted and source-available, works with OpenAI or models on your own hardware, with no required outside cloud.
Safe to update. Gradual rollouts and automatic rollback mean a bad build never bricks the field.

How iotta compares

The reference point is xiaozhi (xinnan-tech/xiaozhi-esp32-server), the open-source platform iotta replaces. The xiaozhi column is grounded in xinnan-tech/xiaozhi-esp32-server, including its own §15 "Known Limitations".

Capability	iotta	xiaozhi
Stack to operate	One Python service + SQLite	Python + Java/Spring + MySQL + Redis + NGINX + separate ASR process
Deploy	`docker compose up`, one host	Multi-service; Redis cache-flush footguns (§15.3)
Stability under load	Stateless app, clean session drain	Daily container restart to work around a socket leak (§15.2)
Auth / transport	Per-device tokens, TLS by default, constant-time compares	Auth often disabled; default DB creds; "not security-assessed" (§15.8)
Real device liveness	True connect/disconnect state	`last_connected_at` = OTA poll, not sessions (§15.6)
Safe OTA	Signed, staged %, min-version gate, rollback + health-gated auto-rollback	Flat `ai_ota` table; infinite-retry bug when empty (§15.4)
Session tracing + replay	Yes (structured, replayable)	No (only a perf tester + a test-audio page)
Eval / regression	Yes (scored suites)	No
Tool / prompt versioning	Yes (`draft → staged → active`)	Runtime plugins; no versioned contract
3rd-party API visibility	Call inspector + per-turn tokens, TTFT, per-stage/multi-hop timing	Per-component latency only
Web dev simulator	Browser client on the real protocol (visible traffic, tool calls, errors)	Browser audio test page only
Audio input debugging	Lossless PCM uplink capture + mid-session mode switch + trace playback	Browser test page only
Provider-agnostic	Yes (config swap)	Yes (very large adapter list)
Runtime shape	Multi-step pipeline or all-in-one speech-to-speech, A/B-testable with one eval suite	Multi-step pipeline (ASR → LLM → TTS)
AI pipeline	ASR → LLM → TTS + tools; memory/RAG/vision extend behind the same provider interfaces	+ VAD, voiceprint, memory, RAG, vision today
Multi-user / RBAC	Roles + audit log (commercial tier)	Users + super-admin/standard today
Production posture	TLS, backup, preflight built in	"Not suitable for production without hardening" (§15.8)

The trade in plain terms: iotta's bet is operational simplicity, update safety, and visibility — the exact axes where xiaozhi tends to burn a team trying to ship a product. xiaozhi carries more AI-pipeline breadth (memory/RAG/voiceprint/vision) today; in iotta those pieces sit behind the same clean provider interfaces, so they extend the platform rather than rewrite it.

Editions

iotta is offered open-core, self-hosted:

Community — free; the full development platform; capped at a small number of active devices (for demos, solo use, and evaluation).
Commercial — a license raises/removes the device cap and unlocks team features (multi-user roles + audit, advanced rollout automation, long-retention analytics).

The core always runs with no required cloud dependency. See commercialization.md for the model, the enforcement design, and a pricing/packaging sketch.