A new open-source project called Moumantai (, meaning "no problem") is trying to solve a real pain point for self-hosters and indie hackers: writing apps that work across your phone, watch, browser, and embedded displays without maintaining separate codebases for each. The project dropped on Hacker News over the weekend with a deceptively simple pitch—define your app once, let the server handle state and logic, and render it natively wherever you are.

How It Works

Moumantai follows a server-authoritative architecture where the backend owns all application state, capability execution, and presentation resolution. Plugin apps define their data through Drizzle schemas, expose capabilities as "tools," and specify UI surfaces called "faces." The agent layer—powered by an LLM of your choice—handles natural language interpretation and fuzzy logic within those deterministic boundaries. Code handles the known; the agent handles the ambiguous. This isn't another prompt playground—it's meant to produce durable software you can inspect, fork, and remix. The protocol separates concerns cleanly: clients (PWA, Android, Wear OS, ESP32) only handle device interaction and rendering, while apps remain independent of any particular client or model provider. The shared TypeScript/Kotlin/C types generated from .proto files ensure contracts stay consistent across implementations. Tools mutate state; faces read it—boundaries are explicit by design.

Clients: From Browser to Watch to ESP32 Panel

Moumantai ships with thin clients for multiple platforms, each mapping the same typed protocol to platform-specific toolkits. The PWA (React + Vite) serves as the universal entry point and fastest path to getting started—no compilation required. Android gets a native Kotlin + Compose M3 client for deeper OS integration, while Wear OS watches get glanceable interactions through Kotlin + Wear Compose. For embedded scenarios—wall displays, desk panels, IoT projects—the ESP32 firmware (ESP-IDF + LVGL in C) handles always-on ambient rendering.

Agent Backend Flexibility

The default backend uses Claude Agent SDK with Anthropic models, accepting either OAuth tokens from claude setup-token or API keys from console.anthropic.com. But Moumantai doesn't lock you into one provider—the project also supports Pi Coding Agent as an alternative harness, which can connect to over two dozen providers including OpenAI, Google, and Bedrock. Provider credentials stay on the server and never touch clients or plugin apps.

Developer Experience

Getting started requires cloning with git submodule initialization, installing mise for toolchain management (Node 22, Python 3.12, JDK 17), and running an interactive setup wizard that configures your workspace location (~/.moumantai/ by default) and LLM credentials. Two terminals: one for the WebSocket server in watch mode, one for Vite hot-reload on the PWA. Pairing is enabled by default—devices must be allowlisted before connecting—and there's a dev mode toggle (MOUMANTAI_DEV_MODE=1) that lets coding agents draft apps in isolation before you promote them to production.

Early Stage Reality Check

The project makes no bones about being early: expect rough edges, changing APIs, and the usual startup friction. No standalone binary exists—you run admin commands through task server:cli from the checkout. Hot-reload doesn't propagate to transitive app imports, so editing schema.ts or parts.ts requires a server restart. The bundled spend-tracker plugin serves as the reference implementation.

Key Takeaways

  • Server-authoritative architecture keeps state ownership clear across all device clients
  • Schema/Tools/Faces pattern gives deterministic code and LLM flexibility well-defined boundaries
  • Clients exist for PWA, Android, Wear OS, and ESP32—each rendering the same app differently per context
  • Agent backend abstraction supports multiple harnesses and providers beyond Claude
  • MIT licensed, fully self-hosted with no vendor lock-in