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 del MCP de Android. Permite que tus apps se comporten como servidores de MCP en el dispositivo, lo que contribuye con funciones que actúan como herramientas para que las usen las funciones proactivas junto con agentes y asistentes, como Google Gemini. A partir de mayo de 2026, la integración de AppFunctions con Gemini se encuentra en versión preliminar privada con verificadores de confianza. Ya puedes comenzar a preparar tus apps para usar AppFunctions y herramientas para desarrolladores.

Cuando defines estas AppFunctions, habilitas tu app para que 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 el MCP estandariza tradicionalmente la forma en que los agentes se conectan a las herramientas del servidor, las AppFunctions proporcionan el mismo mecanismo para las apps para Android. Esto te permite exponer las funciones de tu app como "herramientas" orquestables que las apps autorizadas (emisores de llamadas) pueden descubrir y ejecutar para cumplir con las intenciones del usuario. Los emisores 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 que ejecutan Android 16 o versiones posteriores.

Ejemplos de casos de uso

AppFunctions proporciona un mecanismo potente para automatizar tareas y optimizar las interacciones de los usuarios. Cuando abres las funciones de tu app, permites que los usuarios alcancen objetivos complejos con lenguaje natural, lo que suele reemplazar la necesidad de navegar de forma manual y paso a paso 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 de AppFunction: El emisor identifica la app de administración de tareas pertinente y, luego, invoca una función para crear una tarea, lo 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
   */
  @AppFunctionDeclaration(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 de AppFunction: El emisor ejecuta una función de creación de playlists dentro de una app de música y pasa el contexto, como "los mejores álbumes de jazz de 2026", como la consulta 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.
   */
  @AppFunctionDeclaration(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 de AppFunction: Esta solicitud usa funciones de varias apps. Primero, el emisor usa la función de búsqueda de una app de correo electrónico para recuperar el contenido. Luego, extrae los ingredientes pertinentes y, para completar la lista del usuario, invoca una función de la app de lista de compras.

  /**
   * 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.
   */
  @AppFunctionDeclaration(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
   */
  @AppFunctionDeclaration(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 de agente aprobada invoca la función "crear evento" de la app de calendario y analiza el contexto relevante, como "el próximo lunes" y "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.
   */
  @AppFunctionDeclaration(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 las 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 controlen 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 Jetpack de AppFunctions 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 los metadatos de AppFunction consultándolos. Además de los KDocs específicos de las funciones, los desarrolladores pueden definir patrones y restricciones operativos a nivel de la app en los metadatos de la app para guiar la organización de los agentes 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 Jetpack de AppFunctions simplifica la exposición de la funcionalidad de tu app. Con el procesador de anotaciones, anotas las funciones que quieres que estén disponibles para los agentes. Luego, los emisores pueden descubrir e invocar estas funciones indexadas con AppFunctionManager.

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

No es necesario que tu app verifique 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 la función es compatible o no.

Este es un ejemplo de AppFunctions para una app de toma de notas con funciones 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.
     */
    @AppFunctionDeclaration(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

Pusimos a disposición los siguientes recursos para ayudarte a mejorar tus habilidades en AppFunctions:

• Explora la muestra de AppFunctions para verificar y explorar cómo funciona todo en tus dispositivos.
• Usa la habilidad de agente de 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 de alto valor para la organización de la 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: Optimiza 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 local y la depuración integrado en el dispositivo.
• Para realizar pruebas y verificaciones en la línea de comandos, usa comandos de ADB, como adb shell cmd app_function ..., como una forma directa y ligera de probar el registro de funciones, inspeccionar las descripciones de metadatos y ejecutar funciones integrado en el 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 las instrucciones detalladas en las secciones anteriores.

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

Ambos permiten que los agentes de IA organicen 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, el desarrollo 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?

AppFunctions es 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 de 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 --package con el nombre del paquete de tu app.

¿Puedo obtener acceso anticipado a la experiencia de desarrollador de agentes de extremo a extremo?

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

¿Cómo puedo enviar comentarios sobre AppFunctions?

Para enviar comentarios sobre la API, presenta un problema y registra tu interés en el formulario del Programa de acceso anticipado.