Lancement de SAEP par Doubao : Comment les applications peuvent restreindre l'automatisation par IA

Doubao lance SAEP ? Le 14 septembre 2026, ByteDance a officiellement annoncé l'édition grand public de son assistant mobile Doubao, en partenariat avec le fabricant de matériel Nubia, pour le lancement sur le Nubia NaviX Ultra (disponibilité commerciale prévue le 16 septembre 2026). Parallèlement à la reconnaissance d'écran multimodale et à un bouton IA matériel dédié, ByteDance a introduit le Screen Automation Execution Protocol (SAEP), un cadre de gouvernance au niveau de l'application entrant dans une période de consultation publique de 30 jours. Le SAEP accorde aux développeurs d'applications tierces l'autorité de déclarer explicitement si les agents IA sont autorisés ou non à effectuer une automatisation d'écran au sein de leurs applications. Pour les architectes de logiciels mobiles, les responsables de la sécurité et les ingénieurs en télémétrie, l'avènement du cadre de gouvernance Doubao SAEP marque une transition importante : le passage d'une automatisation visuelle de l'interface utilisateur sans contrainte vers un modèle de gouvernance déclaratif émergent qui redéfinit la manière dont les logiciels mobiles régissent les interactions automatisées.

Intégration matérielle et modèle déclaratif SAEP

Le lancement de l'édition grand public de l'assistant mobile Doubao marque l'évolution des assistants d'écran conversationnels vers des moteurs d'exécution de tâches proactifs. Selon les rapports publiés par IT Home et OSCHINA, la version grand public se concentre sur la stabilité quotidienne, la persistance du contexte multimodal et l'exécution inter-applications via sa fonctionnalité bêta « Operate Phone ».

En bref

• Support matériel commercial : Lancement sur le Nubia NaviX Ultra le 16 septembre 2026, avec un chemin de mise à jour prévu pour les appareils plus anciens tels que le Nubia M153.
• Entrée physique et perception d'écran : Combine une touche IA physique dédiée dotée d'une autorisation par empreinte digitale biométrique avec une interrogation et une réponse sur écran en temps réel sans nécessiter de captures d'écran manuelles.
• Protocole déclaratif SAEP : Introduit une norme de déclaration opérationnelle au niveau de l'application avec une fenêtre de révision publique de 30 jours, permettant aux applications tierces d'autoriser ou de restreindre explicitement l'automatisation d'écran pilotée par l'IA.
• Cadre de protection des agents : Établit un cadre de protection des agents à plusieurs niveaux conçu pour renforcer les limites opérationnelles, les mécanismes de sécurité contrôlés par l'utilisateur et la sécurité opérationnelle.

Tel que documenté dans les annonces officielles et rapporté par le gouvernement municipal de Pékin, le modèle d'interaction physique lie l'intention à l'autorisation. La touche IA dédiée intègre la vérification par empreinte digitale pour lier l'invocation authentifiée sur l'appareil au lancement de l'assistant, garantissant que la confirmation d'identité se produit au moment de l'initiation de l'action.

Au-delà de la réponse visuelle aux questions, le système permet à l'assistant d'analyser les éléments contextuels à l'écran et d'exécuter des tâches séquentielles sur plusieurs outils tiers. Pour empêcher les actions non autorisées, la version introduit le protocole SAEP. Plutôt que de laisser la limite de l'automatisation au comportement ponctuel du modèle ou aux paramètres par défaut du système d'exploitation, SAEP redonne la définition des limites d'automatisation aux développeurs d'applications.

Étapes clés de la version de l'assistant mobile Doubao et du SAEP

Déconstruction du paradigme des agents d'interface graphique : pourquoi le fonctionnement des combinés exige une gouvernance au niveau des applications

Dans des analyses techniques de la publication technologique Ifanr, la transition pilotée par les agents au niveau du système est décrite éditorialement comme transformant les smartphones en « terminaux d'action ». Les systèmes d'exploitation mobiles traditionnels fonctionnent comme des catalogues fonctionnels : les applications restent passives jusqu'à ce qu'un utilisateur humain les ouvre, navigue dans leurs hiérarchies visuelles et saisisse manuellement des données.

Les agents d'interface graphique (GUI) multimodaux au niveau du système modifient ce pipeline en introduisant des boucles perception-action automatisées :

1. Capture d'écran et de contexte : L'agent ingère l'affichage actif et les informations contextuelles via des capacités système autorisées, lisant le contexte visuel et textuel sans nécessiter de balisage explicite du développeur.
2. Planification d'intention multimodale : Un modèle de base traduit les commandes en langage naturel (par exemple, « Vérifie mon calendrier, planifie un itinéraire en fonction de la météo actuelle et règle une alarme de départ ») en séquences d'actions discrètes.
3. Exécution d'action simulée : L'agent utilise des capacités autorisées au niveau du système pour exécuter des tapotements, des balayages et des saisies de texte sur les applications tierces installées de manière séquentielle.

Bien que l'exécution inter-applications rationalise les flux de travail complexes, elle introduit des défis importants en matière de sécurité, de commerce et de responsabilité. Si un agent autonome entre dans une application bancaire, peut-il initier des transactions financières sans ré-authentification explicite ? Si un agent traverse une application sociale, peut-il publier du contenu de manière autonome ?

Historiquement, les systèmes d'exploitation manquaient de mécanismes granulaires permettant aux applications de communiquer leur posture d'automatisation à des agents IA externes. Sous les architectures standard Android AccessibilityService, les autorisations sont des bascules système accordées par l'utilisateur liées à des capacités déclarées, telles que la spécification de canRetrieveWindowContent pour accéder aux nœuds de fenêtre active ou la configuration de canPerformGestures pour envoyer des entrées tactiles. Bien que puissantes, ces capacités fonctionnent du point de vue de ce que le service d'assistance est autorisé à faire, plutôt que de permettre aux applications cibles de définir des limites précises pour les outils d'IA externes.

Conceptuellement, le SAEP inverse cette direction de gouvernance : comme détaillé par le 21st Century Business Herald, les applications cibles peuvent déclarer explicitement si l'automatisation pilotée par l'IA est autorisée ou restreinte au sein de leurs applications ou limites opérationnelles déclarées. Dans le cadre du protocole, l'assistant mobile Doubao s'engage à respecter ces déclarations des développeurs, garantissant que les interactions explicitement restreintes ne seront pas automatisées.

Opérationnalisation des limites déclaratives : une architecture de référence inspirée par le SAEP

Le protocole d'exécution d'automatisation d'écran (SAEP) établit un contrat de gouvernance au niveau de l'application entre les logiciels tiers et les agents d'automatisation au niveau du système. Plutôt que de s'appuyer sur des heuristiques visuelles pour deviner si une interaction est sûre, les cadres déclaratifs permettent aux applications de publier directement leur posture opérationnelle.

Bien que ByteDance ait établi le principe fondamental des déclarations d'autorisation/refus tierces et un système de protection des agents en couches, les spécifications techniques formelles, les définitions de schéma et les API d'intégration restent soumises à la révision publique de 30 jours en cours. L'architecture et le code ci-dessous décrivent un modèle conceptuel de référence démontrant comment les équipes d'ingénierie peuvent opérationnaliser les limites de politique déclaratives au sein des applications clientes.

Note sur la portée de l'ingénierie : Les contrôles et implémentations de référence suivants représentent des modèles de conception d'ingénierie inspirés par la direction de gouvernance publique du SAEP et le modèle de protection en couches rapporté par Doubao ; il ne s'agit pas d'exigences API SAEP officielles divulguées ou de spécifications techniques finalisées.

+-------------------------------------------------------------------------+
|              ARCHITECTURE DE RÉSOLUTION DE POLITIQUE D'AGENT CONCEPTUELLE             |
+-------------------------------------------------------------------------+
|                                                                         |
|  [ INTENTION UTILISATEUR ]                                                        |
|  Commande en langage naturel (ex: "Commander des fournitures ménagères depuis l'app")   |
|         |                                                               |
|         v                                                               |
|  [ MOTEUR D'ORCHESTRATION D'AGENT SYSTÈME ]                                  |
|  - Analyse l'intention cible, planifie le graphe de tâches et cible l'application      |
|         |                                                               |
|         v                                                               |
|  [ COUCHE DE RÉSOLUTION DE POLITIQUE D'APPLICATION ]                                |
|  - Inspecte le manifeste d'automatisation déclaré / registre de politique de l'app cible |
|  - (Modèle conceptuel ; la représentation réelle du SAEP peut différer)            |
|         |                                                               |
|         +---------------------------------------+                       |
|         | (Automatisation déclarée : AUTORISÉE)      | (Déclarée : RESTREINTE)|
|         v                                       v                       |
|  [ CHEMIN D'EXÉCUTION DE L'AGENT ]               [ OPÉRATION SUSPENDUE ]         |
|  - Procède à une saisie simulée        - L'agent cède l'exécution        |
|  - Les tâches à fort impact déclenchent une reprise utilisateur       - Invite de prise en main humaine        |
|    ou ré-authentification de l'appareil             présentée pour terminer l'action  |
|         |                                                               |
|         v                                                               |
|  [ JOURNALISATION DE LA PROVENANCE DE L'APPLICATION ]                                     |
|  - L'application enregistre le contexte de session pour examen d'audit interne        |
|                                                                         |
+-------------------------------------------------------------------------+

1. Déclaration conceptuelle au niveau de l'application

Dans un modèle déclaratif inspiré par les principes du SAEP, les applications peuvent différencier les zones opérationnelles :

• Vues publiques / informationnelles : Les surfaces dédiées à la navigation dans le catalogue, à l'exploration de produits ou à la lecture informationnelle peuvent être signalées comme ouvertes à la navigation automatisée.
• Vues restreintes / sensibles : Les surfaces à fort impact — telles que l'autorisation de paiement, les informations d'identification de compte ou les transferts de fonds — peuvent être signalées comme restreintes, demandant à l'agent d'arrêter l'exécution automatisée et de demander une prise en main directe par l'utilisateur.

2. Considérations sur la protection à plusieurs niveaux

Pour prendre en charge une automatisation sûre, les environnements d'exécution s'appuient sur des considérations défensives en couches :

• Délimitation par le privilège minimal : En tant que recommandation de sécurité générale, les opérations automatisées doivent être évaluées tâche par tâche, empêchant les processus en arrière-plan d'assumer des privilèges d'exécution globaux.
• Reprise humaine explicite : Dans les flux de travail de sécurité commerciale rapportés, les transactions sensibles mettent en pause l'exécution automatisée, invitant l'utilisateur à terminer manuellement les paiements ou les saisies sensibles. Les fonctionnalités matérielles des appareils, telles que la touche IA avec empreinte digitale du NaviX Ultra, servent de points de contrôle d'authentification matérielle lors des interactions au niveau de l'appareil, plutôt que de champ biométrique universel au niveau du protocole.
• Journalisation de la provenance côté application : Lorsque la plateforme expose des signaux de provenance d'interaction, la journalisation côté application sert de pratique d'ingénierie recommandée pour enregistrer les sessions médiatisées par des agents pour la sécurité interne et l'examen d'audit.

// Implémentation Android / Kotlin illustrative démontrant une architecture de référence
// côté application inspirée par les principes de protocole déclaratif (tels que le SAEP).
// Note : Les spécifications officielles du SAEP et les schémas de manifeste restent soumis à une révision publique en cours ;
// le code suivant représente un modèle de conception d'ingénierie illustratif, et non une implémentation SDK officielle.

package com.example.app.security.automation

enum class OperationalScope {
    INFORMATIONAL_READ,    // Navigation de contenu, détails de produit, exploration de catalogue
    INTERACTIVE_INPUT,     // Requêtes de recherche, saisie de données de formulaire, application de filtre
    RESTRICTED_OPERATION   // Traitement de paiement, saisie d'identifiants, configuration de compte
}

data class ClientAutomationPolicy(
    val scope: OperationalScope,
    val isAutomationPermitted: Boolean,
    val requiresManualTakeover: Boolean
)

object ApplicationPolicyRegistry {
    private val policyMap = mutableMapOf<String, ClientAutomationPolicy>()

    init {
        // Enregistrer des limites déclaratives illustratives sur des itinéraires d'application exemples
        registerRoutePolicy(
            routePath = "catalog/browse",
            policy = ClientAutomationPolicy(
                scope = OperationalScope.INFORMATIONAL_READ,
                isAutomationPermitted = true,
                requiresManualTakeover = false
            )
        )
        registerRoutePolicy(
            routePath = "cart/review",
            policy = ClientAutomationPolicy(
                scope = OperationalScope.INTERACTIVE_INPUT,
                isAutomationPermitted = true,
                requiresManualTakeover = false
            )
        )
        // Désigner les interfaces de transaction sensibles comme non automatisables
        registerRoutePolicy(
            routePath = "checkout/payment",
            policy = ClientAutomationPolicy(
                scope = OperationalScope.RESTRICTED_OPERATION,
                isAutomationPermitted = false,
                requiresManualTakeover = true
            )
        )
    }

    fun registerRoutePolicy(routePath: String, policy: ClientAutomationPolicy) {
        policyMap[routePath] = policy
    }

    fun resolvePolicy(routePath: String): ClientAutomationPolicy {
        return policyMap[routePath] ?: ClientAutomationPolicy(
            scope = OperationalScope.RESTRICTED_OPERATION,
            isAutomationPermitted = false,
            requiresManualTakeover = true
        )
    }
}

class AgentExecutionGuard {
    sealed class EvaluationOutcome {
        object Allowed : EvaluationOutcome()
        object ProhibitedByPolicy : EvaluationOutcome()
        object RequiresHumanTakeover : EvaluationOutcome()
    }

    /**
     * Évalue si une action automatisée doit procéder sur l'itinéraire spécifié.
     * Consulte les déclarations de politique d'application avant que les actions tactiles simulées ne se produisent.
     */
    fun evaluateAction(routePath: String, isAgentDriven: Boolean): EvaluationOutcome {
        if (!isAgentDriven) {
            return EvaluationOutcome.Allowed
        }

        val policy = ApplicationPolicyRegistry.resolvePolicy(routePath)

        if (!policy.isAutomationPermitted) {
            return EvaluationOutcome.ProhibitedByPolicy
        }

        if (policy.requiresManualTakeover) {
            return EvaluationOutcome.RequiresHumanTakeover
        }

        return EvaluationOutcome.Allowed
    }
}

Implications émergentes pour la télémétrie mobile et l'intention de l'utilisateur

À mesure que les agents d'interface graphique au niveau du système deviennent plus répandus, leur impact s'étend au-delà de la sécurité du système d'exploitation vers l'analyse mobile, la télémétrie des produits et la mesure de l'engagement.

Pendant plus d'une décennie, de nombreux flux de travail d'analyse de produits ont implicitement traité les événements d'interaction au sein des applications comme des indicateurs directs de l'engagement des utilisateurs.

Les agents GUI introduisent des nuances à cette base analytique :

• Intention déléguée vs directe : Lorsqu'un agent parcourt un catalogue ou appuie sur un élément d'interface pour atteindre l'objectif global d'un utilisateur, l'action reflète l'intention réelle de l'utilisateur, mais manque d'inspection visuelle humaine directe des états d'interface utilisateur intermédiaires.
• Cadence et synchronisation des sessions : L'exécution automatisée des tâches peut couvrir des files d'attente de tâches asynchrones ou des flux de travail d'exécution en plusieurs étapes, produisant des vitesses d'interaction et des intervalles d'événements qui diffèrent des modèles de navigation humaine manuelle.
• Désambiguïsation de la télémétrie : À mesure que les normes déclaratives évoluent, les plateformes d'analyse de produits pourraient de plus en plus bénéficier de la distinction entre les interactions humaines directes et les opérations médiatisées par des agents pour garantir une analyse de cohorte comportementale précise.

Découplage de la gouvernance des agents intégrés à l'application de la limite d'installation externe

Bien que les cadres de protocole comme le SAEP régissent l'exécution des agents IA au sein des applications installées, l'acquisition d'utilisateurs et la découverte de produits fonctionnent fréquemment selon des cycles de vie distincts avant qu'une application ne soit installée. En marketing multicanal, les utilisateurs potentiels découvrent des services via des pages d'accueil Web mobiles, des promotions d'affiliation ou des campagnes de recherche. Si un agent IA aide un utilisateur à découvrir un nouveau service nécessitant l'installation d'une application mobile native, l'interaction transite par le Web ouvert et via une place de marché d'applications.

+-------------------------------------------------------------------------+
|              PARCOURS D'ACQUISITION MOBILE AVAL SÉPARÉ             |
+-------------------------------------------------------------------------+
|                                                                         |
|  [ Point de contact externe : Page Web mobile / Page de campagne ]            |
|  Contexte capturé : ?channel=ai_discovery&campaign_id=cmp_804&ref=partner  |
|         |                                                               |
|         v                                                               |
|  [ L'utilisateur initie l'installation / Navigue vers l'App Store ]               |
|         |                                                               |
|         v                                                               |
|  [ LA LIMITE D'INSTALLATION : La distribution standard du Store ne           |
|    transmet pas les paramètres de requête Web dans le binaire natif compilé ]          |
|         |                                                               |
|         v                                                               |
|  [ L'utilisateur ouvre l'application native pour la première fois (démarrage à froid) ]                   |
|         |                                                               |
|         v                                                               |
|  [ Moteur de lien profond différé : correspondance de contexte assistée par serveur ]     |
|         |                                                               |
|         v                                                               |
|  [ Canal éligible / Contexte de campagne restauré & Itinéraire appliqué ]       |
|                                                                         |
+-------------------------------------------------------------------------+

Les flux d'installation standard des magasins d'applications ne transfèrent pas les paramètres de requête Web ou les métadonnées de référence dans le binaire de l'application lors du téléchargement. Lors du démarrage à froid initial, l'application ne peut pas identifier nativement quelle campagne ou quel contenu Web spécifique a motivé l'installation.

Pour combler cette limite d'installation, les équipes d'ingénierie utilisent des architectures de gestion de liens distinctes :

Dans les architectures mobiles d'entreprise, les équipes de développement déploient des cadres de liens profonds différés tels que Branch, AppsFlyer, Adjust ou Opoinstall. Une plateforme comme Opoinstall enregistre les métadonnées de clics Web pré-installation éligibles — telles que les balises de canal marketing ou les références SKU de produit — avant que l'utilisateur ne passe à la place de marché des applications.

Lors du démarrage à froid initial de l'application, le SDK client interroge le backend du fournisseur pour récupérer le contexte différé éligible associé à l'interaction pré-installation. Selon la documentation officielle de la plateforme sur la page d'accueil d'Opoinstall, ce cadre de passage de paramètres différé peut restaurer les paramètres au premier lancement dans jusqu'à 98 % des cas éligibles, offrant une alternative automatisée aux codes promotionnels manuels (éliminant les codes d'invitation manuels).

Les limites architecturales doivent être préservées : Le lien profond différé fonctionne strictement au-delà de la limite d'installation de l'application. Il ne régit pas les autorisations des agents IA lors de l'exécution, et ne remplace pas les protocoles au niveau de l'application comme le SAEP. Au lieu de cela, le DDL garantit que les paramètres de campagne contextuels survivent à la transition de la découverte Web externe vers les séquences de démarrage à froid natives, tandis que les cadres de gouvernance lors de l'exécution comme le SAEP définissent la manière dont les agents interagissent avec l'application une fois installée.

Principaux enseignements pour les architectes mobiles et les responsables de l'ingénierie

Le déploiement commercial par ByteDance de l'assistant mobile Doubao et l'introduction du SAEP mettent en évidence une évolution significative dans l'ingénierie logicielle mobile. À mesure que les agents IA évoluent d'incrustations conversationnelles vers des moteurs d'exécution autonomes, les développeurs d'applications doivent passer d'observateurs passifs à définisseurs de politique proactifs.

Pour se préparer à l'expansion des agents d'interface graphique au niveau du système, les équipes d'ingénierie devraient donner la priorité à trois initiatives architecturales :

• Préparer des politiques d'automatisation déclaratives : Passer en revue les zones de surface de l'application pour identifier les flux de travail transactionnels sensibles, en préparant des configurations déclaratives alignées sur les normes émergentes comme le SAEP pour définir des limites opérationnelles claires pour les assistants IA.

• Adapter la télémétrie à l'intention déléguée : Évaluer les pipelines d'analyse intégrés à l'application pour surveiller les modèles émergents de navigation médiatisée par des agents, garantissant que les métriques comportementales reflètent fidèlement la valeur commerciale réelle.

• Maintenir une infrastructure d'acquisition indépendante : S'assurer que les entonnoirs d'acquisition externes restent découplés de la gouvernance des agents lors de l'exécution en déployant des liens universels vérifiés et des liens profonds différés (Deferred Deep Linking) pour préserver le contexte d'intégration des utilisateurs au-delà de la limite d'installation.

Références

• IT Home. (2026). Sortie de l'édition grand public de l'assistant mobile Doubao : lancement d'un protocole de coopération GUI pour permettre aux applications tierces d'autoriser ou de restreindre l'automatisation IA .

• 21st Century Business Herald. (2026). Les assistants IA peuvent-ils entrer dans les applications ? Doubao donne le choix aux applications tierces .

• OSCHINA. (2026). Sortie officielle de l'édition grand public de l'« assistant mobile Doubao » .

• Ifanr. (2026). Prise en main du nouvel assistant mobile Doubao : comment les smartphones deviennent des « terminaux d'action » .

• Beijing Municipal People’s Government. (2026). Sortie officielle de l'édition grand public de l'assistant mobile Doubao .

• Android Developers. (2026). Référence API AccessibilityService. Documentation Android.

• Android Developers. (2026). Référence API AccessibilityServiceInfo. Documentation Android.

• Apple Developer. (2026). Prise en charge des liens universels dans votre application. Documentation Apple.

• Opoinstall. (2026). Présentation des liens profonds différés et de l'installation d'application paramétrée.