Open Minis Deep Dive: Mature Architecture for On-Device AI Agent

From 3 Months of Iteration to Full Open Source: The Evolution of Open Minis

In July 2026, Open Minis founder Ethan Wang announced on X that the full iOS and Android codebase was being open-sourced. The tweet quickly went viral in the developer community — "possibly the best Agent app on your phone" — after 3-4 months of intensive iteration, the app was already serving tens of thousands of users' daily workflows.

As of August 2026, Open Minis has garnered 3,900+ stars and 457 forks on GitHub, making it the most-watched open-source project in the mobile AI Agent space. MacStories' Federico Viticci called it "the most impressive indie app I've seen in a while," and a Zhihu review noted it "has largely achieved and even locally surpassed Apple Intelligence."

Open Minis is not another ChatGPT wrapper. Its core differentiator is giving the AI model a real computer — a full Linux environment running on your phone, plus browser automation, deep device integration, and an extensible skill system.

Why On-Device AI Agent Is the Next Battlefield

The Ceiling of Cloud Agents

Current mainstream AI Agent frameworks — whether DeerFlow, CrewAI, or AutoGen — all run on cloud servers. This architecture has several fundamental limitations:

1. Privacy boundary: Users' health data, calendars, contacts, and photos must be uploaded to the cloud for the Agent to process
2. Latency issues: Every interaction requires a network round-trip, making instant response impossible
3. Offline unusability: On planes, in subways, or in areas with poor signal, the Agent is completely paralyzed
4. Linear cost growth: Every call from every user consumes cloud compute — the larger the scale, the higher the cost

Structural Advantages of On-Device Agents

The on-device AI architecture represented by Open Minis solves all of the above problems:

Dimension	Cloud Agent	Open Minis (On-Device)
Data privacy	Data leaves device	All processed locally
Latency	100-500ms network round-trip	<10ms local calls
Offline capability	Completely unusable	Core functions available
Device integration	Requires extra API bridging	Native deep integration
Cost model	Linear per-token growth	One-time dev, marginal cost approaches zero
System permissions	Limited by API scope	Full device capabilities

This doesn't mean cloud Agents have no value — complex reasoning tasks and large-scale data processing still require cloud compute. But for personal assistant scenarios, on-device Agents have structural advantages in privacy, latency, and user experience.

Core Architecture Analysis: iOS and Android Dual-Platform Implementation

Overall Architecture

Open Minis' codebase is cleanly structured:

src/ios/          iOS app (Swift / SwiftUI) + Share Extension + Widget + File Provider
src/android/      Android app (Kotlin / Compose) + JNI native code
src/shared/       Resources shared by both platforms
deps/             Native dependency build scripts and vendored sources
docs/specs/       Architecture and interface specifications
scripts/          Rootfs preparation and developer tooling

The project uses the GPLv3 license because it links GPLv3 iSH (iOS) and GPLv2 PRoot (Android).

Core Innovation: In-Device Linux Sandbox

Open Minis' most significant technical breakthrough is running a complete Linux environment inside the phone. This isn't a simple terminal emulator — it's a fully functional sandboxed operating system.

iOS: Based on an ARM64 fork of the iSH project. iSH implements Linux usermode emulation, running Alpine Linux on iOS. The Agent can install packages, run scripts, and work with real files.

Android: Based on PRoot user-space chroot. PRoot creates an isolated Linux environment without root access, also running Alpine Linux.

The build process is quite complex — the first build takes 30-60 minutes because all native dependencies are compiled from source:

# iOS build order matters: FFmpeg links against LAME
./deps/build_lame.sh          # LAME 3.100 static library
./deps/build_ffmpeg.sh        # FFmpeg 6.1.2 framework bundles
./deps/build_ish.sh           # iSH kernel libraries
./deps/prepare_alpine_rootfs.sh   # Alpine aarch64 minirootfs

# Android requires NDK r28+
./deps/build_proot.sh && ./scripts/prepare_android_sandbox.sh

Skill System

Open Minis' skill system is the core of its extensibility. A Skill is a folder containing a SKILL.md file — instructions, optional scripts, references, and assets.

Key design decision: Open Minis doesn't require skills written specifically for it. Skills built for Claude Code, Codex, OpenClaw, or Hermes Agent generally run in Minis as-is. Skills adapted to Minis' tools run better — because they can directly access the Linux shell, device integrations, and native offloads.

# Example SKILL.md structure
---
name: health-analyzer
description: Analyze health data and generate reports
triggers: [health, exercise, sleep]
---

## Instructions
When the user asks about health data:
1. Fetch data via HealthKit/Google Fit API
2. Run analysis scripts in the Linux sandbox
3. Generate Markdown-format report

## Scripts
- scripts/analyze.py: Main data analysis script
- scripts/export_health.sh: Data export utility

The skill repository OpenMinis/MinisSkills already includes TTS, search, media downloads, health analysis, cloud APIs, and more.

Device Integration Layer

Open Minis exposes device capabilities as tools the Agent can call:

Integration	iOS Implementation	Android Implementation
Health data	HealthKit	Google Fit / Health Connect
Calendar	EventKit	Android Calendar Provider
Reminders	Reminders	AlarmManager
Contacts	Contacts framework	ContactsContract
Smart home	HomeKit	TBD
Bluetooth	CoreBluetooth	BluetoothAdapter
Clipboard	UIPasteboard	ClipboardManager
Shortcuts	Shortcuts app	TBD

This deep integration means the Agent doesn't just chat — it can actually manipulate the user's device. Photograph a meal and log nutrition data, extract tasks from a Telegram group and write them to Reminders, organize web content into calendar events.

Native Offloads

Heavy or platform-specific work is offloaded to native code rather than executed inside the sandbox. This includes:

• Media processing: FFmpeg and LAME compiled as native frameworks — MP3 encoding, video transcoding done directly in the native layer
• Tokenization: cppjieba Chinese tokenization library compiled as native library
• Math rendering: KaTeX native rendering
• Speech recognition: RealTimeCutVADLibrary for real-time voice activity detection

This hybrid architecture lets Open Minis maintain sandbox security without sacrificing efficiency on performance-critical paths.

Technical Challenges and Solutions for On-Device AI

Challenge 1: Compute Limits for Model Inference

Phones can't run 70B parameter models. Open Minis' solution is Bring Your Own Model (BYOM):

• Supports Claude, GPT, Gemini and other major providers
• Users bring their own API keys or account sign-in
• Inference happens in the cloud, but data is processed locally on-device

This isn't pure "on-device inference" — it's "on-device orchestration." The Agent's orchestration logic runs locally; inference can borrow cloud compute. This pragmatic architecture balances capability and feasibility.

Challenge 2: Memory and Storage Management

The Linux sandbox requires additional memory and storage. Open Minis' strategies:

• Alpine Linux minirootfs: Minimal root filesystem with only necessary tools
• On-demand installation: Agent can apk add required packages inside the sandbox
• Workspace isolation: Different tasks use separate workspaces, addressable via minis://workspace/

Challenge 3: Battery and Thermal Management

Sustained Agent activity drains battery and generates heat. Open Minis mitigates this through:

• Native offloads: Heavy compute goes through native code, more efficient than sandbox execution
• Background restrictions: iOS and Android system limits naturally prevent excessive background activity
• User control: Users can set Agent activity permissions and trigger conditions

Challenge 4: Sandbox Escape Security

Running a full Linux environment on-device introduces security risks. Open Minis' multi-layer defense:

• Usermode emulation: Neither iSH nor PRoot require kernel privileges; no direct hardware access
• Filesystem isolation: Sandbox filesystem is isolated from the main system
• Network permission control: Agent's network access is constrained by app permissions
• Open-source audit: Full code is open-source; the security community can review it

Comparison with Cloud Agents

Feature	DeerFlow	CrewAI	Open Minis
Runtime	Cloud server	Cloud server	Mobile device
Language	Python	Python	Swift/Kotlin
Multi-Agent	✅ Supported	✅ Core feature	❌ Single Agent
Device integration	❌ None	❌ None	✅ Deep integration
Offline capability	❌ Unusable	❌ Unusable	✅ Core functions work
Privacy	❌ Data goes to cloud	❌ Data goes to cloud	✅ Local processing
Complex reasoning	✅ Strong	✅ Strong	⚠️ Depends on external models
Deployment complexity	Medium	Medium	High (native deps compilation)

Open Minis doesn't aim to replace cloud Agent frameworks — it provides a better solution for personal assistant scenarios. For multi-Agent collaboration and large-scale data processing, DeerFlow or CrewAI remain better choices.

Open Source Code Structure Deep Dive

iOS Architecture

src/ios/
├── Minis.xcodeproj/          # Xcode project configuration
├── Minis/                    # Main app
│   ├── App/                  # App entry and lifecycle
│   ├── Views/                # SwiftUI views
│   ├── Models/               # Data models
│   ├── Services/             # Business logic services
│   ├── Agent/                # Agent core logic
│   │   ├── Runtime/          # Runtime environment
│   │   ├── Tools/            # Tool definitions
│   │   └── Skills/           # Skill loader
│   └── Integrations/         # Device integrations
│       ├── HealthKit/
│       ├── Calendar/
│       └── Shortcuts/
├── MinisShare/               # Share Extension
├── AgentWidgetExtension/     # Widget
└── MinisFileProvider/        # File Provider

The iOS端 uses Swift 6.0 and SwiftUI, targeting iOS 26.2. The project includes multiple targets: main app, Share Extension (for receiving shares from other apps), Widget, and File Provider.

Android Architecture

src/android/
├── app/                      # Main app module
│   ├── src/main/
│   │   ├── java/             # Kotlin code
│   │   │   └── app/openminis/
│   │   │       ├── ui/       # Compose UI
│   │   │       ├── agent/    # Agent core
│   │   │       ├── sandbox/  # PRoot sandbox management
│   │   │       └── tools/    # Tools and device integration
│   │   └── jni/              # JNI native code
│   └── build.gradle.kts
└── buildSrc/                 # Build configuration

The Android端 uses Kotlin and Jetpack Compose, JDK 17. The JNI layer handles native interactions for the PRoot sandbox.

Cross-Platform Sharing

src/shared/ contains resources shared by both platforms, but core logic is implemented independently per platform. This "shared resources, independent logic" strategy suits deep system integration apps better than cross-platform frameworks like React Native or Flutter.

How Developers Can Build Their Own Mobile Agent on Open Minis

Quick Start

# Clone repository (with submodules)
git clone --recurse-submodules https://github.com/OpenMinis/OpenMinis.git
cd OpenMinis

# iOS build
./deps/build_lame.sh && ./deps/build_ffmpeg.sh
./deps/build_ish.sh && ./deps/prepare_alpine_rootfs.sh
open src/ios/Minis.xcodeproj

# Android build
./deps/build_proot.sh && ./scripts/prepare_android_sandbox.sh
cd src/android && ./gradlew :app:assembleDebug

Custom Skill Development

1. Create a skill folder with SKILL.md
2. Define triggers and instructions
3. Optionally add scripts and references
4. Submit to the MinisSkills repository

Build Setup

Before the first build, copy configuration templates:

cp src/ios/Configs/ProviderCustomization.xcconfig.example \
   src/ios/Configs/ProviderCustomization.xcconfig

cp src/android/app/provider-customization.properties.example \
   src/android/app/provider-customization.properties

Leaving values empty is fine — the app compiles and runs. API-key sign-in doesn't require any customization.

Real-World Use Cases and User Experience

Based on community feedback and official documentation, Open Minis' high-frequency use cases:

Nutrition tracking: Photograph a meal, identify food, estimate calories and macros, auto-log to Apple Health.

Morning briefing: Shortcuts triggers Minis to fetch your X timeline, summarize it, synthesize speech, and play it as your alarm.

Task extraction: Pull messages from a Telegram group, extract bugs and action items, deduplicate, and file into Apple Reminders.

Note management: Mount your Obsidian vault — research, clean up, and write Markdown notes back.

Calendar events: Share anything to Minis via iOS Share Sheet; it creates a calendar event with time and place included.

User reviews are generally positive — "possibly the best app I've used in recent years. I use it every day to explore new possibilities," "Great product! Silky smooth experience!"

Limitations and Future Directions

Current Limitations

1. No PRs accepted: The repo is a mirror of a private development tree; Pull Requests are not accepted — only Issues
2. Complex first build: 30-60 minutes compile time, multiple native dependencies must be built in order
3. Not pure on-device inference: Still relies on cloud model APIs, not true on-device inference
4. Platform disparity: Some features (HomeKit, Shortcuts) are iOS-only; Android has fewer features
5. GPLv3 license: Restrictions on commercial use

Future Directions

• More native offloads: Migrate more heavy compute to native code
• Android feature parity: HomeKit equivalents, Shortcuts alternatives
• Skill ecosystem expansion: More community-contributed skills
• Multi-Agent collaboration: Possibly introduce DeerFlow-like multi-Agent architecture
• On-device small model support: Integrate Phi-3, Gemma, and other small local models

Final Assessment

Open Minis represents a mature architecture for mobile AI Agents. It's not a simple model wrapper — it's a complete on-device computing platform that gives AI a real computer to operate on: file systems, web browsing, and device capabilities.

Strengths: - True on-device Agent with clear privacy and latency advantages - Deep device integration that goes beyond chatbots - Extensible skill system compatible with existing Agent ecosystem - Fully open-source, auditable by the community

Weaknesses: - High build complexity, steep on-ramp for newcomers - Still depends on cloud models, not pure on-device inference - Unconventional no-PR open-source model

Who it's for: - Privacy-conscious personal AI assistant users - Developers wanting to deeply customize their mobile Agent - Researchers interested in on-device AI architecture

Open Minis proves one thing: in the age of AI, technical design and code are no longer where a product's advantage lies. The best Agent emerges from a tight feedback loop with the people who use it — their expectations and their reports are what converge on the product. That's why the team chose to fully open-source — letting the community shape the product's future together.

---

Frequently Asked Questions (FAQ)

Q1: Is Open Minis completely free? A1: Yes, Open Minis is completely free and open-source (GPLv3). However, using models like Claude, GPT, or Gemini requires your own API keys or accounts, and these model services may charge fees.

Q2: Can Open Minis be used without internet? A2: Core functions work offline — the Linux sandbox, file operations, and installed skills all run offline. But if you use cloud models (Claude, GPT, etc.), the inference portion requires a network connection. Local small model support may come in the future.

Q3: Is Open Minis' Linux sandbox safe? Will it affect my phone's system? A3: The sandbox runs in usermode emulation (iSH on iOS, PRoot on Android), requires no root/jailbreak, and cannot directly access hardware or the main system filesystem. Multi-layer isolation ensures operations inside the sandbox don't affect your device's security.

Q4: Can I contribute code to Open Minis? A4: The repository is a mirror of a private development tree and currently doesn't accept Pull Requests. But you can report bugs and suggest features via GitHub Issues, and contribute skills and use cases to the MinisSkills and AwesomeMinis repositories.

Q5: Which AI models does Open Minis support? A5: It supports major providers including Claude (Anthropic), GPT (OpenAI), and Gemini (Google). You can use them via API key or account sign-in. Refer to the official documentation for the specific model list.