Analyse approfondie d'Open Minis : Architecture mature pour agents IA open source sur mobile

De 3 mois d'itération à l'open source complet : Le chemin d'évolution d'Open Minis

En juillet 2026, Ethan Wang, fondateur d'Open Minis, a annoncé sur X l'ouverture complète du code source iOS et Android. Ce tweet a rapidement provoqué une explosion dans la communauté des développeurs — "possibly the best Agent app on your phone". Après 3-4 mois d'itération intensive, cette application sert déjà les workflows quotidiens de dizaines de milliers d'utilisateurs.

En août 2026, Open Minis a accumulé 3 900+ étoiles et 457 forks sur GitHub, devenant le projet open source le plus suivi dans le domaine des agents IA mobiles. Federico Viticci de MacStories l'évalue comme "the most impressive indie app I've seen in a while", et une évaluation sur Zhihu indique qu'il "réalise dans une large mesure et dépasse même localement Apple Intelligence".

Open Minis n'est pas une autre application wrapper ChatGPT. Sa différenciation clé réside dans : Donner à l'IA un véritable ordinateur — un environnement Linux complet fonctionnant sur l'appareil mobile, complété par l'automatisation du navigateur, l'intégration profonde de l'appareil et un système de compétences extensible.

Pourquoi les agents IA sur appareil sont le prochain champ de bataille

Le plafond des agents cloud

Les frameworks d'agents IA mainstream actuels — qu'il s'agisse de DeerFlow, CrewAI ou AutoGen — fonctionnent tous sur des serveurs cloud. Cette architecture présente plusieurs limitations fondamentales :

1. Limites de confidentialité : Les données de santé, calendriers, contacts et photos des utilisateurs doivent être téléchargés dans le cloud pour que l'agent puisse les traiter
2. Problèmes de latence : Chaque interaction nécessite un aller-retour réseau, rendant les réponses instantanées impossibles
3. Indisponibilité hors ligne : Dans l'avion, le métro ou les zones à faible signal, l'agent est complètement paralysé
4. Coûts linéairement croissants : Chaque appel de chaque utilisateur consomme de la puissance de calcul cloud, plus l'échelle est grande, plus les coûts sont élevés

Avantages structurels des agents sur appareil

L'architecture IA sur appareil représentée par Open Minis résout tous les problèmes ci-dessus :

Cela ne signifie pas que les agents cloud n'ont pas de valeur — les tâches d'inférence complexes et le traitement de données à grande échelle nécessitent toujours de la puissance de calcul cloud. Mais pour les scénarios d'assistants personnels quotidiens, les agents sur appareil ont des avantages structurels en matière de confidentialité, de latence et d'expérience utilisateur.

Analyse de l'architecture de base : Implémentation双端 iOS et Android

Architecture globale

La base de code d'Open Minis est clairement structurée :

src/ios/          Application iOS (Swift / SwiftUI) + Share Extension + Widget + File Provider
src/android/      Application Android (Kotlin / Compose) + code natif JNI
src/shared/       Ressources partagées双平台
deps/             Scripts de construction de dépendances natives et code source des fournisseurs
docs/specs/       Spécifications d'architecture et d'interface
scripts/          Préparation du système de fichiers racine et outils de développement

Le projet utilise la licence GPLv3 car il lie iSH sous GPLv3 (iOS) et PRoot sous GPLv2 (Android).

Innovation de base : Sandbox Linux dans l'appareil

La percée technologique la plus importante d'Open Minis est l'exécution d'un environnement Linux complet à l'intérieur de l'appareil mobile. Ce n'est pas un simple émulateur de terminal, mais un système d'exploitation sandbox entièrement fonctionnel.

Côté iOS : Basé sur le fork ARM64 du projet iSH. iSH implémente la simulation en mode utilisateur Linux et exécute Alpine Linux sur iOS. L'agent peut installer des paquets, exécuter des scripts et manipuler de vrais fichiers.

Côté Android : Basé sur le chroot en espace utilisateur PRoot. PRoot crée un environnement Linux isolé sans permissions root et exécute également Alpine Linux.

Le processus de construction est assez complexe — la première construction prend 30-60 minutes car toutes les dépendances natives sont compilées à partir du code source :

# L'ordre de construction iOS est important : FFmpeg lie avec LAME
./deps/build_lame.sh          # Bibliothèque statique LAME 3.100
./deps/build_ffmpeg.sh        # Bundles de framework FFmpeg 6.1.2
./deps/build_ish.sh           # Bibliothèque de noyau iSH
./deps/prepare_alpine_rootfs.sh   # minirootfs Alpine aarch64

# Android nécessite NDK r28+
./deps/build_proot.sh && ./scripts/prepare_android_sandbox.sh

Système de compétences (Skills)

Le système de compétences d'Open Minis est le cœur de son extensibilité. Une compétence est un dossier contenant un fichier SKILL.md — avec des instructions, des scripts optionnels, des références et des actifs.

Décision de conception importante : Open Minis ne nécessite pas de compétences spécialement écrites pour lui. Les compétences construites pour Claude Code, Codex, OpenClaw ou Hermes Agent peuvent généralement être exécutées directement dans Minis. Les compétences adaptées à l'environnement d'outils Minis fonctionnent mieux — car elles peuvent accéder directement au shell Linux, à l'intégration de l'appareil et au déchargement natif.

# Exemple de structure SKILL.md
---
name: health-analyzer
description: Analyse les données de santé et génère des rapports
triggers: [santé, exercice, sommeil]
---

## Instructions
Lorsque l'utilisateur demande des données de santé :
1. Récupérer les données via l'API HealthKit/Google Fit
2. Exécuter le script d'analyse dans la sandbox Linux
3. Générer un rapport au format Markdown

## Scripts
- scripts/analyze.py : Script principal d'analyse de données
- scripts/export_health.sh : Outil d'exportation de données

Le référentiel de compétences OpenMinis/MinisSkills contient déjà diverses compétences telles que TTS, recherche, téléchargement de médias, analyse de santé et API cloud.

Couche d'intégration d'appareil

Open Minis expose les capacités de l'appareil comme des outils appelables par l'agent :

Cette intégration profonde signifie que l'agent ne se contente pas de discuter — il peut réellement contrôler l'appareil de l'utilisateur. Prendre des photos pour reconnaître les aliments et enregistrer les données nutritionnelles, extraire des tâches des groupes Telegram et les écrire dans les rappels, organiser le contenu web en événements de calendrier.

Déchargement natif (Native Offloads)

Les travaux de calcul intensif ou spécifiques à la plateforme sont déchargés vers du code natif, plutôt que d'être exécutés à l'intérieur de la sandbox. Cela inclut :

• Traitement des médias : FFmpeg et LAME sont compilés en frameworks natifs, le codage MP3 et la transcodage vidéo sont effectués directement dans la couche native
• Tokenisation : La bibliothèque de tokenisation chinoise cppjieba est compilée en bibliothèque native
• Rendu mathématique : Rendu natif KaTeX
• Reconnaissance vocale : RealTimeCutVADLibrary implémente la détection d'activité vocale en temps réel

Cette architecture hybride permet à Open Minis de maintenir la sécurité de la sandbox sans sacrifier l'efficacité des chemins critiques pour les performances.

Défis techniques et solutions pour l'IA sur appareil

Défi 1 : Limitations de puissance de calcul pour l'inférence de modèle

Les appareils mobiles ne peuvent pas exécuter de grands modèles à 70B paramètres. La solution d'Open Minis est Bring Your Own Model (BYOM) :

• Prend en charge les fournisseurs mainstream comme Claude, GPT, Gemini
• Les utilisateurs apportent leurs propres clés API ou connexions de compte
• L'inférence est effectuée dans le cloud, mais les données sont traitées localement sur l'appareil

Ce n'est pas une "inférence sur appareil" pure, mais une "orchestration sur appareil" — la logique d'orchestration de l'agent est locale, l'inférence peut emprunter de la puissance de calcul cloud. Cette architecture pragmatique équilibre capacités et faisabilité.

Défi 2 : Gestion de la mémoire et du stockage

La sandbox Linux nécessite de la mémoire et de l'espace de stockage supplémentaires. La stratégie d'Open Minis :

• Alpine Linux minirootfs : Système de fichiers racine minimaliste, ne contenant que les outils nécessaires
• Installation à la demande : L'agent peut installer les paquets nécessaires dans la sandbox avec apk add
• Isolation de l'espace de travail : Différentes tâches utilisent des espaces de travail indépendants, adressés via minis://workspace/

Défi 3 : Gestion de la batterie et de la chaleur

L'activité continue de l'agent consomme de la batterie et génère de la chaleur. Open Minis atténue cela par :

• Déchargement natif : Les calculs intensifs passent par du code natif, plus efficace que l'exécution dans la sandbox
• Limitations d'arrière-plan : Les limitations du système iOS et Android empêchent naturellement une activité d'arrière-plan excessive
• Contrôle utilisateur : Les utilisateurs peuvent définir les permissions d'activité et les conditions de déclenchement de l'agent

Défi 4 : Évasion de sandbox de sécurité

L'exécution d'un environnement Linux complet sur l'appareil présente des risques de sécurité. La défense multicouche d'Open Minis :

• Simulation en mode utilisateur : Ni iSH ni PRoot ne nécessitent de permissions de noyau, pas d'accès direct au matériel
• Isolation du système de fichiers : Le système de fichiers de la sandbox est isolé du système principal
• Contrôle des permissions réseau : L'accès réseau de l'agent est soumis aux permissions de l'application
• Audit open source : Le code complet est open source, la communauté de sécurité peut examiner

Comparaison avec les agents cloud

Open Minis ne vise pas à remplacer les frameworks d'agents cloud, mais offre une meilleure solution dans les scénarios d'assistants personnels. Pour les scénarios nécessitant une collaboration multi-agents et un traitement de données à grande échelle, DeerFlow ou CrewAI restent de meilleurs choix.

Analyse approfondie de la structure du code open source

Architecture iOS

src/ios/
├── Minis.xcodeproj/          # Configuration du projet Xcode
├── Minis/                    # Application principale
│   ├── App/                  # Point d'entrée et cycle de vie de l'application
│   ├── Views/                # Vues SwiftUI
│   ├── Models/               # Modèles de données
│   ├── Services/             # Services de logique métier
│   ├── Agent/                # Logique de base de l'agent
│   │   ├── Runtime/          # Environnement d'exécution
│   │   ├── Tools/            # Définitions des outils
│   │   └── Skills/           # Chargeur de compétences
│   └── Integrations/         # Intégration d'appareil
│       ├── HealthKit/
│       ├── Calendar/
│       └── Shortcuts/
├── MinisShare/               # Share Extension
├── AgentWidgetExtension/     # Widget
└── MinisFileProvider/        # File Provider

Le côté iOS utilise Swift 6.0 et SwiftUI, version cible iOS 26.2. Le projet contient plusieurs cibles : application principale, Share Extension (pour recevoir des partages d'autres applications), Widget et File Provider.

Architecture Android

src/android/
├── app/                      # Module d'application principale
│   ├── src/main/
│   │   ├── java/             # Code Kotlin
│   │   │   └── app/openminis/
│   │   │       ├── ui/       # UI Compose
│   │   │       ├── agent/    # Noyau de l'agent
│   │   │       ├── sandbox/  # Gestion de la sandbox PRoot
│   │   │       └── tools/    # Outils et intégration d'appareil
│   │   └── jni/              # Code natif JNI
│   └── build.gradle.kts
└── buildSrc/                 # Configuration de construction

Le côté Android utilise Kotlin et Jetpack Compose, JDK 17. La couche JNI gère les interactions natives de la sandbox PRoot.

Partage multiplateforme

src/shared/ contient des ressources partagées par les deux plateformes, mais la logique de base est implémentée indépendamment sur chaque plateforme. Cette stratégie "ressources partagées, logique indépendante" convient mieux aux applications nécessitant une intégration système profonde que les frameworks multiplateformes comme React Native ou Flutter.

Comment les développeurs peuvent construire leurs propres agents mobiles basés sur Open Minis

Démarrage rapide

# Cloner le dépôt (incluant les sous-modules)
git clone --recurse-submodules https://github.com/OpenMinis/OpenMinis.git
cd OpenMinis

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

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

Développement de compétences personnalisées

1. Créer un dossier de compétence contenant SKILL.md
2. Définir les conditions de déclenchement et les instructions
3. Ajouter optionnellement des scripts et des références
4. Soumettre au référentiel MinisSkills

Configuration de construction

Avant la première construction, les modèles de configuration doivent être copiés :

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

Laisser vide pour compiler et exécuter — la connexion par clé API ne nécessite aucune configuration personnalisée.

Scénarios d'utilisation réels et expérience utilisateur

Sur la base des retours de la communauté et de la documentation officielle, voici les scénarios d'utilisation fréquents d'Open Minis :

Suivi nutritionnel : Prendre des photos pour reconnaître les aliments, estimer les calories et les macronutriments, écrire automatiquement dans Apple Health.

Briefing matinal : Shortcuts déclenche Minis pour récupérer la timeline X, générer un résumé, synthétiser la parole et la lire comme réveil.

Extraction de tâches : Récupérer les messages des groupes Telegram, extraire les bugs et les points d'action, dédupliquer et écrire dans Apple Reminders.

Gestion des notes : Monter le coffre-fort Obsidian, rechercher, nettoyer et réécrire les notes Markdown.

Événements de calendrier : Via iOS Share Sheet, partager n'importe quel contenu à Minis, créer automatiquement des événements de calendrier avec heure et lieu.

Les évaluations des utilisateurs sont généralement positives — "C'est probablement la meilleure application que j'ai utilisée ces dernières années, j'explore de nouvelles possibilités chaque jour", "Excellent produit ! L'expérience est fluide comme de la soie !".

Limitations et orientation future

Limitations actuelles

1. Pas de prise en charge des PR : Le dépôt est un miroir de l'arbre de développement privé, n'accepte pas les Pull Requests, les retours se font uniquement via les Issues
2. Première construction complexe : 30-60 minutes de temps de compilation, plusieurs dépendances natives doivent être construites séquentiellement
3. Pas une inférence pure sur appareil : Dépend toujours des API de modèles cloud, pas une véritable inférence sur appareil
4. Différences de plateforme : Certaines fonctions (comme HomeKit, Raccourcis) ne sont prises en charge que par iOS, le côté Android a moins de fonctions
5. Licence GPLv3 : Restrictions pour l'utilisation commerciale

Orientation future

• Plus de déchargement natif : Migrer plus de calculs intensifs vers du code natif
• Complément des fonctions Android : Équivalent de HomeKit, alternatives aux Raccourcis
• Extension de l'écosystème de compétences : Plus de compétences contributées par la communauté
• Collaboration multi-agents : Introduction possible d'une architecture multi-agents similaire à DeerFlow
• Prise en charge de petits modèles sur appareil : Intégration de petits modèles locaux comme Phi-3, Gemma

Évaluation résumée

Open Minis représente une architecture mature pour les agents IA mobiles. Ce n'est pas un simple wrapper de modèle, mais une plateforme de calcul sur appareil complète — l'IA reçoit un véritable ordinateur, capable de manipuler des systèmes de fichiers, de naviguer sur le web et d'intégrer les capacités de l'appareil.

Forces : - Véritable agent sur appareil, avantages évidents en matière de confidentialité et de latence - Intégration profonde de l'appareil, allant au-delà du cadre des chatbots - Système de compétences extensible, compatible avec l'écosystème d'agents existant - Entièrement open source, la communauté peut auditer et contribuer

Faiblesses : - Complexité de construction élevée, seuil d'entrée raide pour les débutants - Dépend toujours des modèles cloud, pas une inférence pure sur appareil - Le mode open source qui n'accepte pas les PR est quelque peu non conventionnel

Pour qui : - Utilisateurs d'assistants IA personnels valorisant la confidentialité - Développeurs souhaitant personnaliser profondément les agents mobiles - Chercheurs intéressés par les architectures IA sur appareil

Open Minis prouve une chose : À l'ère de l'IA, la conception technique et le code ne sont plus l'avantage du produit. Les meilleurs agents proviennent de boucles de rétroaction étroites avec les utilisateurs — leurs attentes et leurs rapports sont les forces qui convergent vers le produit. C'est pourquoi l'équipe a choisi l'ouverture complète du code source — pour que la communauté façonne ensemble l'avenir du produit.

Liens de référence : - Dépôt GitHub : https://github.com/OpenMinis/OpenMinis - Site officiel : https://openminis.app - Dépôt de compétences : https://github.com/OpenMinis/MinisSkills - AwesomeMinis : https://github.com/OpenMinis/AwesomeMinis