Zero

Zero is an Android AI agent app built with Kotlin, Rust, and UniFFI. It runs a long-lived on-device service, exposes tools through a native [Zeroclaw] Rust core, and provides a Compose UI for configuring and operating the agent.

Project status

• Experimental and actively evolving.
• Built for Android 9+ and validated most heavily on recent Pixel hardware. Other devices and OEM builds may need additional validation.
• Large portions of the project were created with AI-assisted tooling and are still being audited and hardened.
• Public collaboration and support are not available as this is a personal project. I just want you all along for the journey!

The Rust core under zeroclaw/ is a stripped and modified descendant of the upstream ZeroClaw project:

• https://github.com/zeroclaw-labs/zeroclaw

They deserve credit for the core runtime work. If you like what powers this app, please support the upstream project directly.

Please do not file issues or support requests with ZeroClaw Labs for behavior that comes from this downstream Android fork.

If you run this project, validate it against your own device, accounts, files, data, and connected services before trusting it with anything important.

What Zero is

Zero is built for people who want an agent that feels personal, local-first, and always available on Android. The goal is for the app to feel less like a generic assistant shell and more like a home for your in-app Zero:

• Android app UI in Kotlin + Jetpack Compose
• Native agent core in Rust
• UniFFI bridge connecting Kotlin and Rust safely
• Foreground daemon/service model for persistent agent execution
• Tooling, channels, memory, scheduling, and plugins under one roof

Zero is designed to be private by default, configurable, and capable of running as more than a chat window. Your in-app Zero should be able to search, remember, route, schedule, and act through a native mobile-first stack.

Current capabilities

Providers

• OpenAI
• Anthropic
• Google Gemini
• xAI (Grok)
• Ollama
• OpenRouter

Channels

• Telegram
• Discord
• Email
• Google Messages
• in-app Terminal / REPL

That means your in-app Zero can live inside the app, speak through connected channels, and keep working through the daemon/runtime model.

Built-in tooling

• web search
• web fetch
• HTTP requests
• vision / multimodal support
• smart message routing + provider cascade
• Twitter/X browsing via authenticated cookies
• eval_script — sandboxed Rhai scripting (agent writes and runs scripts during its own reasoning)

Core systems

• agent config + routing
• memory backends
• cron / scheduling
• Rhai scripting engine with 24-capability security model
• plugin management (Hub: Apps, Skills, Plugins)
• ClawBoy — AI-played Game Boy emulator
• Android-native settings and service controls

Together, these systems make the in-app Zero more than a front-end character - they give Zero an actual runtime, memory, tools, and operational surface.

Architecture

Zero is split into a few major parts:

• app/ - Android app, Compose UI, service orchestration, settings, plugin screens
• zeroclaw/ - Rust core: tools, memory, config, runtime, channels, gateway
• zeroclaw-android/zeroclaw-ffi/ - UniFFI bridge layer exported to Kotlin
• lib/ - Android library packaging for native bindings
• scripts/ - hooks, test helpers, release utilities

The Android layer owns UX, secret storage, and lifecycle for the in-app Zero. The Rust layer owns the agent runtime, tools, config parsing, and execution engine that power Zero underneath.

Upstream ancestry

The zeroclaw/ Rust core in this repository is a stripped and modified version of the upstream project at:

• https://github.com/zeroclaw-labs/zeroclaw

For the zeroclaw/ directory, this repo uses the upstream MIT license option.

Why...?

Zero is not just "an Android chat app." It is an attempt to build a full agent platform around a native mobile runtime, with the in-app Zero at the center of the experience:

• private-first secret handling and local settings
• Rust core for safety and portability
• Android-native UX instead of a thin web wrapper
• persistent service model for always-on workflows
• extensible tool/plugin surface for adding real capabilities over time

Getting started

1. Install JDK 17, the Android SDK for API 35, and a current Rust toolchain.
2. Keep signing files, local.properties, and other machine-local overrides outside the repository tree.
3. Build the Android app with ./gradlew :app:assembleDebug.
4. Before sharing builds, run ./gradlew spotlessCheck detekt :app:testDebugUnitTest :lib:testDebugUnitTest.

Development notes

• Min SDK: Android 9 / API 28
• Target SDK: 35
• Languages: Kotlin + Rust
• Bridge: UniFFI
• Targets: aarch64-linux-android and x86_64-linux-android

Local configuration

• Keep release.jks, local.properties, and scratch directories such as .tmp/ out of the repo tree and out of screenshots or support bundles.
• The Gradle build can load machine-local properties from ZEROAI_LOCAL_PROPERTIES_FILE or from $HOME/.zeroai/local.properties outside the repository.

Support status

• Issues and pull requests are temporarily closed (try making a fork you and your zero can grow together!)
• Please do not use upstream ZeroClaw Labs issue trackers for this downstream fork.

Research

Some of the reverse engineering and protocol work done for this project is documented publicly in case it helps others building similar integrations:

• Google Messages Bugle Protocol — reverse engineering notes on Google's proprietary Messages-for-Web RPC protocol (pairing, encryption, contacts/message sync, media upload)

License

• Top-level app, docs, and assets are covered by the root LICENSE.
• The upstream-derived Rust engine under zeroclaw/ retains its upstream licensing; see zeroclaw/LICENSE-MIT and zeroclaw/LICENSE-APACHE.