Project Info
For a product overview video, visit link
Inspiration
We asked Siri to call us an uber. It replied with "Hey Uber". This got us thinking, even well funded AI voice assistants have quite a long way to go. We want something that can actually get things done. We wanted an agent that can control our devices and do our boring tasks like booking our ubers, ordering us food and spam texting our ex so we didn't have to. We saw the potential of "Blue" (YC S25) but not only are they not yet on the market after almost a year, we also realized a closed ecosystem limits innovation and privacy. We wanted to build an open-source, privacy-first alternative that gives users full control over their own devices using affordable, off-the-shelf hardware.
What it does
Yooni is an open-source voice agent that controls your mobile device to complete real-world tasks, not just productivity tools. Yooni can buy you concert tickets, it can buy your favorite meal on instacart, it can get you a lyft, it can do anything you can do on your phone. Natural Voice Interaction Speak naturally to Yooni (e.g., "Order my usual from DoorDash" or "Text mom I'll be there in 10") Real-time speech-to-text using Whisper and ultra-low latency response Conversational memory to handle follow-up questions and refinements On-Device Control Android: Uses accessibility services and programmatic control to view your screen, tap buttons, swipe, and type text directly in your apps Agent Logic: Understands app layouts and navigates through complex flows (like finding a specific email or changing a setting) without needing special API integrations iOS: Planned support via mobile-use Privacy & Safety Transparent Execution: Yooni explains what it's about to do before taking action Human-in-the-Loop: Asks for explicit confirmation before sensitive actions (like sending money or messages) Open Source: No black box—the agent logic is fully auditable and extendable by the community Local Inference: Compatible with self-hosted voice and multimodal LLMs Intelligent Planning Breaks down vague requests into precise, actionable steps Verifies screen state before and after actions to ensure success Handles errors gracefully by retrying or asking for clarification
How we built it
We built Yooni as a distributed system to handle the heavy lifting of agentic reasoning while keeping the mobile app lightweight. Android App (Kotlin & Jetpack Compose): The frontend is a native Android app that handles voice input (OpenAI Whisper), speech synthesis (TTS), and the user interface. It captures the user's intent and displays the agent's thought process. Brain (Python & Gemini): The core intelligence runs on a backend (prototyped on a Raspberry Pi/local server) using Python. In production, this can run on significantly smaller edge devices, making it convenient for users to handle. We utilize Google's Gemini 3 Pro Preview for the high-level reasoning and planning, transforming vague voice commands into precise, step-by-step navigation instructions. Mobile Control (Mobile-Use): We improved and integrated mobile-use, an open-source framework that allows our agent to interface with the Android operating system, enabling it to "see" the screen hierarchy and simulate touch events. Networking: The Android app and the Python brain communicate via HTTP/WebSockets to stream audio and commands in real-time. Hardware Portability: We cross-compile from an NVIDIA/ASUS Ascent GX10 to support older, widely available hardware—so the community can run Yooni without expensive devices.
Challenges we ran into
Latency vs. Accuracy: Balancing the speed of voice response with the time it takes for the agent to analyze a screen and decide on a tap was tough. We had to optimize our prompt engineering to get faster, reliable actions. Android Permissions: Gaining the necessary accessibility permissions to control other apps programmatically is (rightfully) difficult on Android. We spent a lot of time navigating the security model to allow Yooni to act on the user's behalf safely. Audio Handling: Implementing a robust "wake word" style experience and handling raw audio streams between Kotlin and Python required debugging low-level byte streams and format conversions (PCM to WAV). Old Hardware: Working with an 11-year-old Raspberry Pi to run state-of-the-art mobile agents was a challenge - we used an NVIDIA-provided ASUS Ascent GX110 to cross-compile binaries for it.
Accomplishments we're proud of
End-to-End Voice to Action: We successfully demoed a flow where a simple voice command triggers a real, physical interaction in a third-party app on the phone. Open Source Foundation: We built this on top of open standards, meaning anyone can fork Yooni and add support for their favorite apps or custom workflows. Sleek UI: We built a modern, responsive UI in Jetpack Compose with custom animations (breathing agent circle) that makes the AI feel alive and responsive. Privacy-First Architecture: By design, Yooni is transparent. It doesn't act in a "black box"; the user sees the plan and approves critical steps.
What we learned
Agentic Workflows are Hard: "Planning" is easy for LLMs, but "executing" reliably in a dynamic environment like a smartphone OS is incredibly complex. Screen states change, popups appear, and loading times vary. Voice UI requires Trust: Users need constant feedback. We learned that visual cues (like the breathing animation and text logs) are essential to let the user know the agent is "thinking" or "working," otherwise they think it froze. The Power of Accessibility Services: Android's accessibility layer is incredibly powerful for automation, far beyond just screen reading.
What's next
for Yooni Voice Authentication: Built-in speaker verification ensures only your voice can command Yooni, preventing unauthorized access even if someone else has your phone. On-Device Processing: Moving the LLM inference entirely to the device (using models like Gemini Nano or Llama 3 quantized) for offline capability and ultimate privacy. Visual Understanding: Improving the screen parsing with vision-language models (VLMs) to understand custom UI elements that standard accessibility services miss (like game menus). Proactive Help: Yooni learning your habits and suggesting tasks (e.g., "It's 6 PM, should I order dinner?").
yooni
Open-source AI phone agent. Voice in, phone actions out.
yooni is an open-source, privacy-first voice assistant that takes natural language commands and executes them on your Android device.
Architecture
Android App (Kotlin) Raspberry Pi
- Wake word detection ("Hey yooni") - mobile-use (controls phone via ADB)
- Records speech
- Whisper STT (openai-kotlin)
- LLM formats action (openai-kotlin)
- TTS speaks back for confirmation
- User confirms/refines (voice loop)
- Sends confirmed command ------> websocket/HTTP ------> executes on phone
Two layers
Voice Layer (Android App) - Native Kotlin app that runs on the phone. Listens for the "Hey yooni" wake word using Porcupine (on-device, no network). Once triggered, records speech, transcribes via OpenAI Whisper, uses an LLM to format the command into a clean action preview, and speaks it back via OpenAI TTS for confirmation. User can refine until satisfied, then confirms to execute.
Phone Control Layer (Raspberry Pi) - A Raspberry Pi connected to the Android phone via USB. Runs mobile-use which receives the confirmed command and handles all device interaction over ADB. Reads the screen, decides what to tap/type/swipe, and executes autonomously.
Design
Example flow
User: "Hey yooni, text Mom that I'll be there in 10 mins"
yooni: "I'll send this to Mom: 'Hey! I'll be there in about 10 minutes.' Sound good?"
User: "Add 'do you need anything?'"
yooni: "Got it: 'Hey! I'll be there in about 10 minutes. Do you need anything?' Ready to send?"
User: "Yes"
yooni: sends to Pi, mobile-use executes "Sent!"
File structure
yooni/
├── android/ # Native Android app (Kotlin)
│ ├── app/
│ │ ├── build.gradle.kts # App dependencies (openai-kotlin, ktor, porcupine)
│ │ └── src/main/
│ │ ├── AndroidManifest.xml
│ │ └── java/com/example/yooni/
│ │ ├── MainActivity.kt # App entry point
│ │ ├── WakeWordService.kt # Porcupine "Hey yooni" listener (planned)
│ │ ├── VoiceManager.kt # Recording, Whisper STT, TTS (planned)
│ │ ├── ActionFormatter.kt # LLM formats command (planned)
│ │ ├── ConfirmationLoop.kt # Confirm/refine loop (planned)
│ │ ├── PiClient.kt # Sends commands to Pi (planned)
│ │ └── ui/theme/
│ │ ├── Color.kt
│ │ ├── Theme.kt
│ │ └── Type.kt
│ ├── build.gradle.kts # Root Gradle config
│ └── settings.gradle.kts
├── pi/ # Raspberry Pi server (planned)
│ ├── server.py # Receives commands from Android app
│ └── executor.py # Passes commands to mobile-use
└── README.md
Analysis
View
Metric
- 13
- 8
- 4
- 2
Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.
Technology
- FastAPIIn code
- KotlinIn code
- PythonIn code
- DockerClaimed
- Google GeminiClaimed
- OpenAIClaimed
3 of 6 appear in the indexed code. 3 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.
AI coding agents
- Claude CodeCommits
- CursorCommits
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
198 KB
Source files
45
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
nolawiyonas1/yooni
72 files · 304 KB · @ a42023d
Structure
Interface
21 files · 29%Screens, components and styles rendered to the user.
Application logic
29 files · 40%Domain rules, services and shared utilities.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- XML75%
- Kotlin19%
- Python4%
- Markdown2%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
pi/requirements.txt
pypi · 3- fastapi
- pydantic
- uvicorn[standard]
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
This project’s features have not been analysed yet.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.