Open Minis Review: The Best Mobile AI Agent App, Mature After Months of Iteration

When AI Agents move from desktop to pocket, your phone becomes more than a video-watching device—it transforms into a true intelligent assistant that gets things done. After 3-4 months of rapid iteration, Open Minis has become the most mature AI Agent application on mobile.

One-Sentence Summary

Open Minis is a local-first, on-device AI Agent application (iOS / iPadOS / macOS / Vision Pro / Android), fully open source (GPL v3.0) and free to use. It’s not just chat—it gives your AI a real computer: a Linux Shell running on your device, browser automation, extensible skills system, persistent memory, and deep integration with native frameworks like HealthKit, Calendar, and Reminders.

If ChatGPT is the “mouth”, DeerFlow is the “brain”, and UI-TARS-Desktop is the “hands”, then Open Minis is the “all-around assistant in your pocket”—it packs desktop-grade Agent capabilities into your phone.

What is a Mobile AI Agent? How Does It Differ from Desktop?

What is a Mobile AI Agent?

Traditional AI apps (like ChatGPT App, Gemini App) are essentially “conversation windows”—you ask, it answers, but it can’t do anything for you.

Mobile AI Agents are completely different: they can not only converse but also execute actions—browse the web, manage schedules, control smart home devices, read health data, and automate daily tasks. They transform your phone from a passive consumption device into an active work partner.

Core Differences from Desktop Agents

Dimension	Desktop Agent (UI-TARS-Desktop)	Mobile Agent (Open Minis)
Environment	macOS / Windows / Linux desktop	iOS / Android mobile devices
Interaction	Control mouse and keyboard via GUI	Native framework APIs + Shell + Browser
Use Cases	Office automation, data processing, dev tasks	Daily tasks, health management, smart home, info retrieval
Portability	Fixed at computer	Anywhere, Agent in your pocket
System Integration	File system, applications, terminal	HealthKit, Calendar, Reminders, Bluetooth, Location
Privacy Model	Local execution, data stays on device	Local-first, data not uploaded by default

Key Insight: Desktop Agents excel at “heavy lifting” (batch processing, complex operations), while Mobile Agents excel at “light tasks” (instant response, fragmented tasks, sensor data). They complement rather than replace each other.

Core Capabilities of Open Minis

1. Real Computer Environment: On-Device Linux Shell

Open Minis’s most unique design is running a complete Alpine Linux Shell on your iPhone. This isn’t simulation—it’s a real Linux environment where AI can execute commands, install tools, and run scripts.

This means:

• Have AI write Python scripts and run them directly
• Use curl to fetch web data
• Process files, compress/extract, handle text
• Install additional CLI tools to extend capabilities

Why This Matters: Most phone AI apps can only “talk”, not “do”. Open Minis gives AI a real computer, transforming it from “advisor” to “executor”.

2. Browser Automation

Open Minis has built-in browser automation capabilities:

• Open web pages and extract information
• Fill forms, click buttons
• Take screenshots and analyze page content
• Monitor web page changes

This lets you:

• Have AI check prices and compare
• Automatically fill repetitive forms
• Monitor pages for updates
• Scrape web data for analysis

3. Deep Native Framework Integration

Open Minis isn’t a “browser wrapper”—it deeply integrates iOS native frameworks:

• HealthKit: Read your health data (steps, heart rate, sleep), let AI analyze your health
• Calendar: Manage schedules, create/modify/delete events
• Reminders: Manage to-do items, set reminders
• Music: Control music playback
• Bluetooth: Scan nearby Bluetooth devices, control smart home
• Location: Location-based automation tasks

Real Scenario: You can tell Open Minis “Check if my exercise this week meets the goal, if not, schedule a run for tomorrow and add it to my calendar”—it reads HealthKit data, analyzes, creates calendar events, all in one go.

4. Persistent Memory System

Open Minis uses a Markdown file-based memory system:

• All conversation history automatically saved as Markdown
• AI can recall previous conversations
• You can manually edit memory files to correct AI’s understanding
• Memory stored completely locally, privacy secure

This solves one of AI apps’ biggest pain points: every conversation starts fresh. With memory, AI truly understands your preferences, habits, and context.

5. Extensible Skills System

Open Minis supports custom Skills:

• Community skills repository MinisSkills provides ready-made skills
• Write your own skill instructions in Markdown
• Skills can be combined for complex workflows
• Manage skills via CLI tool (minis-mcp-cli)

Example Skills:

• Smart home control (scan Bluetooth devices, control lights)
• Financial tracking (analyze spending, generate reports)
• Learning assistant (spaced repetition, knowledge cards)
• Travel planning (check weather, book flights, plan itineraries)

6. Multi-Model Support

Open Minis doesn’t lock you to a single model, supporting major AI services:

• Claude (Anthropic)
• GPT-4 / GPT-4o (OpenAI)
• Gemini (Google)
• Plus more OpenAI API-compatible models

You can:

• Switch between models in-app
• Use your own API Key (BYOK mode)
• Choose the best model for each task

Cost Note: Open Minis app itself is free and open source, but using cloud models requires API fees (per-token billing). You can also connect local models for completely free usage.

Technical Architecture

Open Minis has a sophisticated technical architecture worth exploring:

Core Components

┌─────────────────────────────────────┐
│         Open Minis App              │
│  (SwiftUI / Native iOS / Android)   │
├─────────────────────────────────────┤
│  Agent Loop (Chat + Tool Calls)     │
├─────────────────────────────────────┤
│  Tool Layer                         │
│  ├─ Linux Shell (Alpine Linux)      │
│  ├─ Browser Automation              │
│  ├─ Native Frameworks               │
│  │   ├─ HealthKit                   │
│  │   ├─ Calendar / Reminders        │
│  │   ├─ Bluetooth / Location        │
│  │   └─ Music / Photos              │
│  ├─ Memory System (Markdown)        │
│  └─ Skills Engine                   │
├─────────────────────────────────────┤
│  Model Provider Layer               │
│  ├─ Claude API                      │
│  ├─ OpenAI API                      │
│  ├─ Gemini API                      │
│  └─ Custom / Local Models           │
└─────────────────────────────────────┘

Key Design Decisions

1. Why Linux Shell Instead of Native APIs?

Open Minis’s developer made a counterintuitive choice: instead of giving AI native APIs, they gave it a Linux Shell. The logic:

• Massive CLI tool ecosystem: Linux has thousands of CLI tools AI can directly call
• Higher flexibility: Native APIs need pre-definition, Shell can execute any command
• Easier extension: Install new tools for new capabilities, no app code changes needed

This is “inverted” thinking: instead of making AI adapt to the phone, make the phone adapt to AI.

2. Why Markdown for Memory?

• Human-readable and editable: You can open and modify memory files directly
• Version control friendly: Can use Git to manage memory history
• Model-agnostic: No database dependency, works when switching models
• Privacy secure: Plain text files, just encrypt for storage

3. Local-First Privacy Model

Open Minis keeps all data on-device by default:

• Conversation history not uploaded to servers
• Health data, location info processed completely locally
• Only when calling cloud models does conversation content go to the model provider
• You can choose fully local models for zero data leakage

Real Use Cases

Scenario 1: Daily Task Automation

Task: Automatically get weather, news, and schedule every morning

Open Minis Approach:

1. Create a “Morning Briefing” skill
2. Skill instructions: Get weather → Scrape news headlines → Read today’s schedule → Compile briefing
3. Set timed trigger (or via Shortcuts)
4. Auto-execute every morning, push briefing to you

Result: From “manually opening 3 apps to check” to “get all info with one command”.

Scenario 2: Health Management Assistant

Task: Analyze a week’s exercise and sleep data, give improvement suggestions

Open Minis Approach:

1. Read HealthKit steps, exercise duration, sleep data
2. Use Python scripts in Shell for data analysis
3. Compare health goals, find gaps
4. Generate improvement suggestions, create tomorrow’s exercise plan in calendar

Result: From “looking at numbers and analyzing yourself” to “AI analyzes and gives action suggestions”.

Scenario 3: Smart Home Control

Task: Scan nearby Bluetooth devices, control smart lights

Open Minis Approach:

1. Use Bluetooth skill to scan nearby devices
2. Identify smart bulbs (BLE-supporting brands)
3. Send control commands (on/off, brightness, color)
4. Set automation rules (like auto-lights at sunset)

Result: No need to open dedicated smart home apps, control through conversation.

Scenario 4: Information Collection and Organization

Task: Research a topic, compile into report

Open Minis Approach:

1. Use browser automation to search relevant info
2. Scrape content from multiple web pages
3. Use Shell tools (grep, awk, Python) to extract key information
4. Organize into Markdown report
5. Save locally or send to other apps

Result: From “manually browsing 10 pages and copying” to “get organized report with one command”.

Scenario 5: Learning and Knowledge Management

Task: Learn new concepts with spaced repetition

Open Minis Approach:

1. Create a “Spaced Repetition” skill
2. Save learning content as Markdown cards
3. Schedule reviews based on Ebbinghaus forgetting curve
4. Push daily review cards
5. Track learning progress

Result: Turn your phone into a personalized learning assistant.

Installation and Usage Guide

System Requirements

• iOS / iPadOS: iOS 17.0 or later
• macOS: macOS 14.0 or later
• Vision Pro: visionOS 1.0 or later
• Android: Android 10 or later (in testing)

Installation Steps

Method 1: App Store Installation (Recommended)

1. Open App Store on iPhone / iPad
2. Search for “Open Minis”
3. Tap “Get” to download and install
4. Open app, follow setup guide

Method 2: TestFlight Beta

For latest features (may be unstable):

1. Install TestFlight
2. Visit Open Minis website for test link
3. Install beta via TestFlight

Method 3: Source Code Build (Developers)

# Clone repository
git clone https://github.com/OpenMinis/OpenMinis.git
cd OpenMinis

# Open project in Xcode
open OpenMinis.xcodeproj

# Build and run on simulator or device

Initial Configuration

1. Configure Model Provider

Open Minis supports multiple models, you need to configure at least one:

• Using Claude:

  1. Get Anthropic API Key
  2. Add API Key in Open Minis settings
  3. Choose Claude 3.5 Sonnet or Claude 3 Opus

• Using OpenAI GPT:

  1. Get OpenAI API Key
  2. Add API Key in Open Minis settings
  3. Choose GPT-4o or GPT-4

• Using Gemini:

  1. Get Google AI Studio API Key
  2. Add API Key in Open Minis settings
  3. Choose Gemini 1.5 Pro or Gemini 1.5 Flash

2. Grant System Permissions

Based on features you want to use, Open Minis will request permissions:

• HealthKit: Read health data
• Calendar: Manage schedules
• Reminders: Manage to-dos
• Location: Location services
• Bluetooth: Bluetooth devices

Grant permissions as needed; you can deny unnecessary features.

3. Install Skills (Optional)

Install ready-made skills from community repository:

1. Visit MinisSkills repository
2. Choose needed skills, follow installation instructions
3. Or use minis-mcp-cli command-line tool to manage skills

Basic Usage

Start Conversation:

1. Open Open Minis
2. Enter your request in input box
3. AI analyzes request, calls appropriate tools
4. Execution results returned to you

Example Conversations:

You: Check how many steps I walked today, if not 8000 remind me to take a walk this afternoon

Open Minis:
[Reading HealthKit data]
You've walked 5,234 steps today, 2,766 steps short of 8000 goal.
I've created a reminder: walk for 30 minutes at 4 PM.

You: Check tomorrow's weather in Beijing, cancel outdoor run if it rains

Open Minis:
[Querying weather API]
[Reading calendar events]
Rain expected in Beijing tomorrow, 80% precipitation probability.
I've canceled tomorrow's 8 AM "Outdoor Run" event and added note "Canceled due to rain".
Want me to arrange an indoor alternative exercise?

Performance Review

Response Speed

Task Type	Claude 3.5 Sonnet	GPT-4o	Gemini 1.5 Pro
Simple chat	1-2 seconds	1-2 seconds	1-2 seconds
Tool call (single)	2-4 seconds	2-4 seconds	2-4 seconds
Complex task (multi-step)	10-30 seconds	10-30 seconds	10-30 seconds
Browser automation	5-15 seconds	5-15 seconds	5-15 seconds

Note: Response speed mainly depends on model provider API latency; local tool execution is fast (milliseconds).

Battery Consumption

• Light use (10-20 conversations/day): Extra 5-10% battery
• Medium use (50+ conversations/day + tool calls): Extra 15-25% battery
• Heavy use (frequent browser automation + Shell execution): Extra 30%+ battery

Optimization Tips:

• Turn off background refresh when not needed
• Run browser automation tasks on Wi-Fi when possible
• Use more efficient models (like Gemini Flash) for simple tasks

Memory Usage

• App itself: ~150-200 MB
• Linux Shell environment: ~100-150 MB
• Browser automation: Extra 100-200 MB
• Total: ~350-550 MB

Acceptable for modern iPhones (4GB+ RAM).

Privacy and Security Considerations

Data Flow

Your Input
  ↓
[Local Processing] Chat history, memory, skills → Saved on device (encrypted)
  ↓
[Cloud Processing] Call model API → Sent to model provider
  ↓
[Local Execution] Tool calls → Executed on device
  ↓
Return Results

Privacy Protection Measures

1. Local-First Storage

• All chat history, memory, skill files saved on device
• Nothing uploaded to servers by default
• Only current conversation sent when calling cloud models

2. Encrypted Storage

• Sensitive data (like API Keys) encrypted using iOS Keychain
• Memory files can be encrypted with device passcode

3. Minimal Permissions

• Request permissions only when needed
• Each permission can be individually disabled
• No forced permission requirements

4. Open Source Transparency

• Code fully open source, auditable
• No hidden background communications
• Community can verify privacy claims

Security Notes

1. API Key Security

• Don’t use on public devices
• Rotate API Keys regularly
• Set API usage limits to prevent unexpected high costs

2. Skill Security

• Only install skills from trusted sources
• Review skill code to ensure no malicious behavior
• Community skills are reviewed but still use your judgment

3. Shell Execution Security

• AI-executed commands may have risks (like deleting files)
• Recommend running in sandbox environment
• Backup important data

Limitations and Considerations

Current Limitations

1. Model Costs

• Using cloud models requires API fees
• Complex tasks may consume many tokens
• No built-in free models (need to connect your own)

2. Learning Curve

• Powerful but complex configuration
• Need to understand API Keys, skills, Shell concepts
• Not user-friendly for non-technical users

3. Platform Limitations

• iOS version has most complete features
• Android version still in testing, features may be incomplete
• Some features (like HealthKit) iOS-only

4. Network Dependency

• Cloud models require network connection
• Offline scenarios can only use local models (need self-deployment)
• Browser automation needs stable network

5. Battery Consumption

• Heavy use significantly increases power consumption
• Not suitable for long background running

Target Users

Suitable For:

• Tech enthusiasts who like to tinker
• Privacy-conscious users wanting data local
• Efficiency seekers wanting task automation
• Developers wanting custom extensions

Not Suitable For:

• Users just wanting simple chat (ChatGPT App is simpler)
• Completely non-technical users
• Users needing completely offline use (unless deploying local models)

Comparison with Competitors

vs ChatGPT iOS App

Dimension	Open Minis	ChatGPT iOS App
Positioning	Local AI Agent	Cloud chat assistant
Models	Multi-model support	GPT-4o / GPT-4 only
Tool Calls	Shell, browser, native frameworks	Limited plugins
Privacy	Local-first	Data uploaded to OpenAI
Cost	App free + API fees	Free / Plus $20/month
Ease of Use	Medium	Simple
Extensibility	Skills system	Limited

Conclusion: ChatGPT App for simple chat, Open Minis for users needing action execution.

vs Siri + Apple Intelligence

Dimension	Open Minis	Siri + Apple Intelligence
Models	Multi-model support	Apple models only
Tool Calls	Shell, browser, frameworks	Limited system APIs
Extensibility	Skills system	Shortcuts
Privacy	Local-first	Partial cloud processing
Intelligence	High (GPT-4/Claude level)	Medium
Integration	Requires authorization	Native deep integration

Conclusion: Siri more native but limited intelligence; Open Minis more powerful but requires configuration.

vs Other Mobile Agents

Currently no other mature mobile AI Agent apps on market. Open Minis is a pioneer in this field, main competitors still desktop Agents (like UI-TARS-Desktop) or cloud Agents (like Claude Code).

Final Review

Pros

✅ True Local Agent: Not a chat app wrapper, gives AI a real computer ✅ Privacy First: Data not uploaded by default, open source transparent ✅ Powerful Features: Shell, browser, native frameworks, skills system ✅ Multi-Model Support: Not locked to single provider ✅ Completely Free Open Source: GPL v3.0, community-driven ✅ Cross-Platform: iOS / iPadOS / macOS / Vision Pro / Android

Cons

❌ Complex Configuration: Not friendly for non-technical users ❌ Model Costs: Need to pay API fees yourself ❌ Learning Curve: Need to understand Shell, skills concepts ❌ Immature Android Version: Features may be incomplete ❌ Battery Consumption: Heavy use drains battery noticeably

Ratings

Dimension	Rating	Notes
Feature Completeness	9/10	Amazing what a mobile Agent can do
Ease of Use	6/10	Complex configuration, steep learning curve
Privacy Security	10/10	Local-first, open source transparent
Performance	8/10	Response depends on model, overall smooth
Extensibility	9/10	Flexible skills system, active community
Value	8/10	App free, but API fees self-managed

Overall Rating: 8.3/10

Final Recommendation

If You Are:

• Tech enthusiast who likes to tinker → Highly Recommended
• Privacy-conscious user → Highly Recommended
• Efficiency seeker wanting task automation → Recommended
• Regular user just wanting simple chat → Not Recommended (use ChatGPT App)

Open Minis represents a new direction for mobile AI apps: evolving from “chat assistant” to “true Agent”. It’s not perfect, configuration is complex, but it’s currently the most powerful and flexible AI Agent app on phones. After months of rapid iteration, it’s maturing and worth trying for tech enthusiasts.

As AI Agent technology develops, we can expect Open Minis to continue iterating and become more user-friendly. Perhaps one day everyone will have a true AI assistant in their pocket that actually gets things done—and Open Minis is making that day arrive early.

Hope this blog post was helpful!

---

FAQ

Q1: Is Open Minis completely free?

A: The Open Minis app itself is completely free and open source (GPL v3.0), but using cloud AI models (like Claude, GPT-4, Gemini) requires API fees, billed per token. You can also connect local models for completely free usage, but you’ll need to deploy and maintain local model services yourself.

Q2: Which AI models does Open Minis support?

A: Open Minis supports major AI model providers, including:

• Anthropic Claude (Claude 3.5 Sonnet, Claude 3 Opus)
• OpenAI GPT (GPT-4o, GPT-4)
• Google Gemini (Gemini 1.5 Pro, Gemini 1.5 Flash)
• Any model compatible with OpenAI API format

You can freely switch models in-app, using your own API Key.

Q3: Is Open Minis data secure? Will it leak my privacy?

A: Open Minis uses a local-first privacy model:

• All chat history, memory, skill files saved on your device, nothing uploaded to servers by default
• Only when calling cloud models does current conversation content go to the model provider
• Sensitive data (like API Keys) encrypted using iOS Keychain
• Code fully open source, community can audit

If you have extremely high privacy requirements, you can choose fully local models for zero data leakage.

Q4: Can Open Minis be used on Android? Are features complete?

A: Open Minis has an Android version, but it’s still in testing and features may not be as complete as iOS. iOS / iPadOS / macOS / Vision Pro versions have the most complete and stable features. Android users should follow official updates or wait for the official release.

Q5: Can I use Open Minis well without programming skills?

A: Open Minis’s basic chat features don’t require programming knowledge, anyone can use them. But to fully leverage its capabilities (custom skills, Shell commands, browser automation), some technical background is needed. If you’re completely non-technical, we recommend:

1. Start by installing ready-made skills from community repository
2. Refer to official docs and tutorials to learn basic concepts
3. Or consider simpler AI apps (like ChatGPT App)

Open Minis has a steep learning curve, but once mastered, it can do a lot.

---