Descripción general de AppFunctions

AppFunctions es una API de la plataforma de Android con una biblioteca de Jetpack complementaria para simplificar la integración de MCP de Android. Permite que tus apps se comporten como servidores de MCP en el dispositivo, y aporta funciones que actúan como herramientas para el uso de funciones proactivas junto con agentes y asistentes, como Google Gemini. A partir de mayo de 2026, la integración de AppFunctions con Gemini estará en versión preliminar privada con verificadores de confianza. Ya puedes comenzar a preparar tus apps para usar AppFunctions y herramientas de desarrollo.

Cuando defines estas AppFunctions, permites que tu app proporcione servicios, datos y acciones al registro integrado en el SO Android, lo que permite que los usuarios completen tareas a través de agentes y de interacciones a nivel del sistema.

Las AppFunctions son el equivalente móvil de las herramientas dentro del Protocolo de contexto del modelo (MCP). Si bien MCP estandariza tradicionalmente la forma en que los agentes se conectan a las herramientas del servidor, AppFunctions proporciona el mismo mecanismo para las apps para Android. Esto te permite exponer las capacidades de tu app como "herramientas" orquestables que las apps autorizadas (llamantes) pueden descubrir y ejecutar para satisfacer las intenciones del usuario. Los llamadores deben tener el permiso EXECUTE_APP_FUNCTIONS para descubrir y ejecutar AppFunctions, y pueden incluir agentes, apps y asistentes de IA, como Gemini.

AppFunctions está disponible en dispositivos con Android 16 o versiones posteriores.

Ejemplos de casos de uso

Las AppFunctions proporcionan un mecanismo potente para automatizar tareas y optimizar las interacciones del usuario. Cuando abres las capacidades de tu app, permites que los usuarios alcancen objetivos complejos con lenguaje natural, lo que a menudo reemplaza la necesidad de navegar paso a paso y de forma manual por tu IU.

En las siguientes situaciones, se ilustra cómo se pueden usar las AppFunctions para impulsar experiencias en una variedad de categorías de apps:

• Administración de tareas y productividad

  • Solicitud del usuario: "Recuérdame que recoja mi paquete en el trabajo hoy a las 5 p.m.".
  • Acción AppFunction: El llamador identifica la app de administración de tareas pertinente y llama a una función para crear una tarea, que completa automáticamente los campos de título, hora y ubicación según la instrucción del usuario.

  /**
   * Create a new task or reminder with a title, due time, and location.
   *
   * @param title The descriptive title of the task (e.g., "Pick up my package").
   * @param dueDateTime The specific date and time when the task should be completed.
   * @param location The physical location associated with the task (e.g., "Work").
   * @return The created Task
   */
  @AppFunction(isDescribedByKDoc = true)
  suspend fun createTask(
      title: String,
      dueDateTime: LocalDateTime? = null,
      location: String? = null,
  ): Task = TODO()
  AppFunctionApiSnippets.kt

• Medios de comunicación y entretenimiento

  • Solicitud del usuario: "Crea una playlist nueva con los mejores álbumes de jazz de este año".
  • Acción AppFunction: El llamador ejecuta una función de creación de playlists dentro de una app de música y pasa contexto, como "los mejores álbumes de jazz de 2026", como la búsqueda para generar la playlist de inmediato.

  /**
   * Create a new music playlist based on a natural language query.
   *
   * @param query The description used to generate the playlist (e.g., "top jazz albums from 2026").
   * @return The final created playlist based on songs.
   */
  @AppFunction(isDescribedByKDoc = true)
  suspend fun createPlaylistFromQuery(
      query: String,
  ): Playlist = TODO()
  AppFunctionApiSnippets.kt

• Flujos de trabajo entre apps

  • Solicitud del usuario: "Busca la receta de fideos en el correo electrónico de Lisa y agrega los ingredientes a mi lista de compras".
  • Acción AppFunction: Esta solicitud usa funciones de varias apps. Primero, el llamador usa la función de búsqueda de una app de correo electrónico para recuperar el contenido. Luego, extrae los ingredientes pertinentes y llama a la función de una app de lista de compras para completar la lista del usuario.

  /**
   * Search for emails matching a query or sender name to retrieve content like recipes.
   *
   * @param query The search term or contact name (e.g., "Lisa noodle recipe").
   * @return A list of matching email summaries containing the requested information.
   */
  @AppFunction(isDescribedByKDoc = true)
  suspend fun searchEmails(
      query: String,
  ): List<EmailSummary> = TODO()
  
  /**
   * Add a list of items or ingredients to the user's active shopping list.
   *
   * @param items The names of the ingredients or products to add to the list.
   * @return The final shopping list with new items added
   */
  @AppFunction(isDescribedByKDoc = true)
  suspend fun addItemsToShoppingList(
      items: List<String>,
  ): ShoppingList = TODO()
  AppFunctionApiSnippets.kt

• Calendario y programación

  • Solicitud del usuario: "Agrega la fiesta de cumpleaños de mamá a mi calendario para el próximo lunes a las 6 p.m.".
  • Acción de AppFunction: La app agentiva aprobada invoca la función "crear evento" de la app de calendario y analiza el contexto pertinente, como "el próximo lunes" y "a las 6 p.m.", para crear la entrada sin que el usuario tenga que abrir el calendario de forma manual.

  /**
   * Schedule a new event on the user's primary calendar.
   *
   * @param title The name of the calendar event (e.g., "Mom's birthday party").
   * @param startDateTime The specific date and time the event is scheduled to begin.
   * @return The created Event object.
   */
  @AppFunction(isDescribedByKDoc = true)
  suspend fun createCalendarEvent(
      title: String,
      startDateTime: LocalDateTime,
  ): Event = TODO()
  AppFunctionApiSnippets.kt

Cómo funcionan las AppFunctions

En el siguiente diagrama, se ilustra el flujo típico de cómo las apps comparten AppFunctions con un agente y, luego, se ejecutan. Es probable que los agentes consideren tanto las herramientas de MCP remotas del servidor como las AppFunctions locales cuando manejen las solicitudes de los usuarios. El flujo detallado para usar AppFunctions locales es el siguiente:

• Declaración de AppFunction: La app para Android se compila para usar AppFunctions y poner a disposición sus funciones, como "Crear nota" o "Enviar mensaje".
• Generación de esquemas: La biblioteca de AppFunctions de Jetpack genera un archivo de esquema XML que enumera todas las AppFunctions declaradas en la app. El SO Android usa este archivo para indexar las AppFunctions disponibles.
• Recuperación de metadatos: El agente puede recuperar metadatos de AppFunction consultándolos. Además de los KDocs específicos de las funciones, los desarrolladores pueden definir patrones y restricciones operacionales a nivel de la app en los metadatos de la app para guiar la orquestación del agente en varias herramientas.
• Selección y ejecución de AppFunction: Según las instrucciones del usuario, el agente selecciona y ejecuta la AppFunction adecuada con los parámetros correspondientes.

La biblioteca de AppFunctions de Jetpack simplifica la exposición de la funcionalidad de tu app. Con el procesador de anotaciones, puedes anotar las funciones que quieres que estén disponibles para los agentes. Luego, los llamadores pueden descubrir e invocar estas funciones indexadas con AppFunctionManager.

Antes de invocar una función, los llamadores deben verificar que el dispositivo admita la función AppFunctions intentando recuperar una instancia de AppFunctionManager. Una vez que se admita, los llamadores podrán verificar si una función específica está habilitada dentro de una app de destino con isAppFunctionEnabled(packageName,functionId). Para consultar el estado de las funciones en otros paquetes, se requiere android.permission.EXECUTE_APP_FUNCTIONSpermission.

Tu app no necesita verificar si se admite la función AppFunction, ya que esto se controla automáticamente dentro de la biblioteca de Jetpack. Por ejemplo, AppFunctionManager puede verificar si se admite la función.

Este es un ejemplo de AppFunctions para una app de toma de notas con capacidades para crear, editar y enumerar notas:

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "TaskAppFunctionService",
    appFunctionXmlFileName = "task_app_function_service",
)
abstract class BaseTaskAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var taskRepository: TaskRepository

    /**
     * Creates a task based on [createTaskParams].
     *
     * @param createTaskParams The parameter to describe how to create the task.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createTask(
        createTaskParams: CreateTaskParams,
    ): Task = withContext(Dispatchers.IO) {
        // Developers can use predefined exceptions to let the agent know
        // why it failed.
        if (createTaskParams.title == null && createTaskParams.content == null) {
            throw AppFunctionInvalidArgumentException("Title or content should be non-null")
        }

        val id = taskRepository.createTask(
            createTaskParams.title,
            createTaskParams.content
        )

        return@withContext taskRepository
            .getTask(id)
            ?.toTask()
            ?: throw AppFunctionElementNotFoundException("Task not found for ID = $id")
    }

    // Maps internal TaskEntity
    private fun TaskEntity.toTask() = Task(id = id, title = title, content = description)
}
AppFunctionApiSnippets.kt

/** The parameter to create the task. */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class CreateTaskParams(
    /** The title of the task. */
    val title: String?,
    /** The content of the task. */
    val content: String?,
)

/** The user-created task. */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class Task(
    /** The ID of the task. */
    val id: String,
    /** The title of the task. */
    val title: String,
    /** The content of the task. */
    val content: String,
)
AppFunctionApiSnippets.kt

Muestras, habilidades y herramientas de prueba

Para ayudarte a mejorar tus habilidades en AppFunctions, pusimos a tu disposición los siguientes recursos:

• Explora el ejemplo de AppFunctions para verificar y explorar cómo funciona todo en tus dispositivos.
• Usa la habilidad del agente AppFunctions para acelerar el desarrollo en el ciclo de vida de cuatro pasos:
  • Descubrimiento: Analiza tu base de código para identificar y recomendar funciones valiosas para la orquestación de IA.
  • Implementación y configuración: Genera implementaciones de Kotlin y configura los metadatos del sistema y las dependencias de compilación.
  • Refinamiento de KDoc: Se optimizó la documentación de funciones y propiedades para los agentes de IA y el MCP de Android.
  • Pruebas y depuración: Proporciona comandos de adb para la evaluación y depuración integradas en el dispositivo.
• Para las pruebas y la verificación desde la línea de comandos, usa comandos de ADB, como adb shell cmd app_function ..., como una forma directa y liviana de probar el registro de funciones, inspeccionar las descripciones de metadatos y ejecutar funciones integrado en el dispositivo.
• Para experimentar Android MCP en acción y probar flujos de trabajo de extremo a extremo sin necesidad de ninguna instrucción, instala y usa la app para Android del agente de pruebas de AppFunctions en tu dispositivo.

Preguntas frecuentes

En la siguiente sección, se abordan las preguntas frecuentes sobre AppFunctions.

Soy desarrollador de apps. ¿Puedo implementar AppFunctions hoy mismo?

Sí, es posible implementar y probar AppFunctions en tu app siguiendo la guía detallada en las secciones anteriores.

¿Cuál es la diferencia entre AppFunctions y MCP?

Ambos permiten que los agentes de IA coordinen herramientas, pero tienen diferencias significativas en su arquitectura, latencia y esfuerzo requerido por el desarrollador. Las AppFunctions son hooks integrados a nivel del SO exclusivos de Android que se ejecutan de forma local. Por el contrario, un servidor de MCP estándar es una solución independiente de la plataforma que se basa en la ejecución en la nube y los viajes de ida y vuelta de la red.

En resumen, desarrollar con AppFunctions te permite usar el estado existente de la app directamente integrado en el dispositivo y no requiere que mantengas servicios fuera de tu app para Android.

Implementé AppFunctions en mi app. ¿Por qué mi agente del sistema no puede acceder a ellas?

Las AppFunctions son una función experimental. Para evaluar cuidadosamente la calidad de la experiencia general durante esta fase experimental, solo una cantidad limitada de apps y agentes del sistema pueden acceder a toda la canalización.

¿Cómo puedo preparar mi app para la disponibilidad general de AppFunctions?

Considera qué funciones de tu app quieres exponer a la automatización basada en agentes. Puedes implementar AppFunctions en tu app. Para ello, sigue los pasos de las secciones anteriores de esta página y verifica que estén registradas en el dispositivo llamando a adb shell cmd app_function list-app-functions.

¿Puedo obtener acceso anticipado a la experiencia de desarrollo agente de extremo a extremo?

Estamos llevando a cabo un Programa de acceso anticipado (PAA) para incorporar apps seleccionadas en las pruebas de la experiencia del desarrollador integral necesaria para lanzar AppFunctions en producción en Android. Puedes registrar tu interés en integrar tus AppFunctions a través de este formulario de registro para el PAA. Si registras tu interés, NO obtendrás automáticamente acceso a la integración completa. Te enviaremos un correo electrónico si se selecciona tu app para el PAA o para informarte cuando las AppFunctions estén disponibles de forma pública.

¿Cómo puedo enviar comentarios sobre AppFunctions?

Puedes enviar comentarios sobre la API registrando un problema y registrando tu interés en el formulario del Programa de Acceso Anticipado.