Introduction to Keynobi
Relevant source files
The following files were used as context for generating this wiki page:
Keynobi is a specialized Android development companion designed to run alongside IDEs like Android Studio and automation tools like Claude Code. It is built using the Tauri 2.0 framework with a Rust backend and a SolidJS frontend. Unlike a full-featured IDE, Keynobi focuses on optimizing the feedback loop between building, deploying, and debugging Android applications by providing high-performance log streaming and device management.
Sources: README.md:3-8, PITCH.md:3-5
The application is currently focused on macOS and supports Kotlin-based Gradle projects. Its primary value proposition lies in its "agent-ready" architecture, featuring a built-in Model Context Protocol (MCP) server that allows AI agents to interact directly with the local development environment, including triggering builds and reading crash logs.
Sources: README.md:9-11, PITCH.md:19-21
High-Level Architecture
Keynobi utilizes a multi-layered architecture where a high-performance Rust core manages heavy I/O operations (like Logcat streaming and Gradle execution), while a reactive SolidJS frontend provides the user interface.
System Components Diagram
This diagram illustrates the relationship between the user interface, the backend services, and external Android hardware or AI agents.
Sources: README.md:124-150
Core Design Decisions
- Ring Buffer Management: Logcat entries are stored in a 50,000-entry ring buffer within the Rust layer. This prevents excessive memory usage in the frontend, as entries are never serialized to disk and the UI only receives visible slices.
- Batch Processing: To avoid flooding the frontend reactive store, the backend utilizes a 100ms batch emit for Logcat events.
- Persistence Integrity: Project settings use atomic file writes (write-to-temp then rename) to prevent corruption during crashes.
- Type Safety: TypeScript bindings are automatically generated from Rust models using
ts-rs, ensuring IPC contract consistency.
Sources: README.md:144-162, AGENTS.md:11
Technical Stack
The project leverages a modern, performance-oriented stack to ensure low-latency interactions.
| Layer | Technologies |
|---|---|
| Framework | Tauri 2.0 (Rust backend + WKWebView frontend) |
| Frontend UI | SolidJS, TypeScript, Vite |
| State Management | SolidJS Stores (createStore, produce) |
| Backend Runtime | Rust (Tokio async runtime) |
| IPC Type Gen | ts-rs |
| Build Tools | Gradle (External), Cargo, npm |
| Telemetry | Sentry (Browser and Native) |
Sources: AGENTS.md:5-15, src-tauri/Cargo.toml:15-35
Key Features and Capabilities
Keynobi provides a unified surface for common Android development tasks that are typically scattered across terminal panes and IDE tabs.
Feature Matrix
| Feature | Description |
|---|---|
| Project Registry | Multi-project management with automated Gradle root detection. |
| Build Streaming | Real-time Gradle output with ANSI log rendering and structured error lists. |
| Logcat Streaming | Real-time device logs with level/tag/text filtering and crash detection. |
| Device Management | Management of physical hardware and Android Virtual Devices (AVDs). |
| MCP Server | Exposes project state and control to AI agents via the Model Context Protocol. |
| Health Checks | Automated validation of Java, SDK, ADB, and Gradle environments. |
Sources: README.md:18-30, PITCH.md:8-16
API and IPC Endpoints
The frontend communicates with the Rust backend through a series of typed wrappers.
| Endpoint (Rust Command) | Description | File Path |
|---|---|---|
run_gradle_task | Executes Gradle tasks and streams output via a channel. | src/lib/tauri-api.ts |
list_adb_devices | Returns a list of all currently connected Android devices. | src/lib/tauri-api.ts |
get_logcat_entries | Retrieves filtered entries from the Rust ring buffer. | src/lib/tauri-api.ts |
open_project | Validates and opens a directory as an Android project. | src/lib/tauri-api.ts |
Sources: src/lib/tauri-api.ts:80-230
AI Agent Integration (MCP)
A critical component of Keynobi is its implementation of the Model Context Protocol (MCP). This allows external AI agents (like Claude Code) to perform complex operations by interacting with the Keynobi process.
MCP Interaction Flow
This sequence diagram shows how an AI agent uses Keynobi to diagnose a build failure.
Sources: PITCH.md:14-16, src/lib/tauri-api.ts:140-160
Configurable Parameters
System configuration is centralized in AppSettings, covering various modules of the application.
| Setting | Type | Default Goal |
|---|---|---|
autoStart (MCP) | Boolean | Starts the MCP stdio server on app launch. |
buildLogRetention | Number | Days to keep structured build logs. |
uiFontSize | Number | Scalable UI for different monitor setups. |
telemetry | Boolean | Opt-in anonymous crash reporting. |
Sources: src/bindings/AppSettings.ts:16-36, src/App.tsx:85-100
User Interface & Interaction
The interface is designed for power users with a heavy reliance on keyboard shortcuts and a command palette.
- Command Palette: Accessed via
Cmd+Shift+P, it allows execution of any registered action (e.g., Clean Project, Select Variant). - Tabbed Interface: Separates concerns into Build (Gradle output) and Logcat (Device logs).
- Sidebars: Provides quick access to the Project Registry (Left) and Device Management (Right).
Sources: src/App.tsx:233-311, README.md:200-213
Conclusion
Keynobi serves as a performance-optimized bridge between local Android development environments and modern AI workflows. By offloading heavy log processing to Rust and providing a standardized MCP interface, it enables both human developers and AI agents to iterate on Android codebases with significantly less friction than traditional terminal-and-IDE setups.
Sources: PITCH.md:24-27