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, lo que contribuye con 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 una versión preliminar privada con verificadores de confianza. Puedes comenzar a preparar tus apps ahora para usar AppFunctions y las 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 sirven como el equivalente para dispositivos móviles 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 capacidades de tu app como "herramientas" orquestables que las apps autorizadas (llamadores) pueden descubrir y ejecutar para cumplir con los intents del usuario. Los llamadores deben tener el EXECUTE_APP_FUNCTIONS permiso 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

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 logren objetivos complejos con lenguaje natural, lo que suele reemplazar la necesidad de una navegación manual paso a paso con 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 llamador identifica la app de administración de tareas pertinente e invoca 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 context The execution context provided by the system.
*   @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(
    context: AppFunctionContext,
    title: String,
    dueDateTime: LocalDateTime? = null,
    location: String? = null
) : Task

  • 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 llamador ejecuta una función de creación de playlist dentro de una app de música y pasa el contexto como "mejores álbumes de jazz para 2026" como la consulta para generar la playlist de inmediato.
    /**
*   Create a new music playlist based on a natural language query.
*
*   @param context The execution context provided by the system.
*   @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(
    context: AppFunctionContext,
    query: String
): Playlist

  • 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 llamador usa la función de búsqueda de una app de correo electrónico para recuperar el contenido. Luego, extrae los ingredientes pertinentes e invoca 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 context The execution context provided by the system.
*   @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(
    context: AppFunctionContext,
    query: String
): List<EmailSummary>

/**
*   Add a list of items or ingredients to the user's active shopping list.
*
*   @param context The execution context provided by the system.
*   @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(
    context: AppFunctionContext,
    items: List<String>
): ShoppingList

  • Calendarios 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 agente aprobada invoca la función "crear evento" de la app de calendario y analiza el contexto pertinente, como "el próximo lunes" y "6 p.m.", para crear la entrada sin que el usuario deba abrir el calendario de forma manual.
    /**
*   Schedule a new event on the user's primary calendar.
*
*   @param context The execution context provided by the system.
*   @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(
    context: AppFunctionContext,
    title: String,
    startDateTime: LocalDateTime
): Event

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 las herramientas de MCP remotas del servidor y las AppFunctions locales cuando manejan las solicitudes del usuario. El flujo detallado para usar AppFunctions locales es el siguiente:

  • Declaración de AppFunction: La app para Android se compila para usar AppFunctions y que sus funciones estén disponibles, como "Crear nota" o "Enviar mensaje".
  • Generación de esquema: La biblioteca de AppFunctions 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 los metadatos de AppFunction consultándolos.
  • 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.
Flujo típico de AppFunctions desde la exposición de la app hasta la ejecución del agente.
Figura 1: El flujo típico de cómo un agente expone y luego ejecuta las AppFunctions.

La biblioteca de AppFunctions Jetpack simplifica la exposición de la funcionalidad de tu app. Con el procesador de anotaciones, anotas las funciones que quieres poner a disposición de 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. Para ello, deben intentar recuperar una instancia de AppFunctionManager. Una vez que se admita, los llamadores 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 android.permission.EXECUTE_APP_FUNCTIONSpermission.

No es necesario que tu app verifique si se admite la función AppFunction. Esto se maneja 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 para tomar notas con capacidades para crear, editar y enumerar notas:

/**
 * A note app's [AppFunction]s.
 */
class NoteFunctions(
    private val noteRepository: NoteRepository
) {
    /**
     * Lists all available notes.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun listNotes(appFunctionContext: AppFunctionContext): List<Note>? {
        return noteRepository.appNotes.ifEmpty { null }?.toList()
    }

    /**
     * Adds a new note to the app.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
        appFunctionContext: AppFunctionContext,
        title: String,
        content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }

    /**
     * Edits a single note.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param noteId The target note's ID.
     * @param title The note's title if it should be updated.
     * @param content The new content if it should be updated.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun editNote(
        appFunctionContext: AppFunctionContext,
        noteId: Int,
        title: String?,
        content: String?,
    ): Note? {
        return noteRepository.updateNote(noteId, title, content)
    }
}

/**
 * A note.
 */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class Note(
    /** The note's identifier */
    val id: Int,
    /** The note's title */
    val title: String,
    /** The note's content */
    val content: String
)

Preguntas frecuentes

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

Soy desarrollador de apps. ¿Puedo implementar AppFunctions hoy?

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 orquesten 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 de la app existente 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 cadena de procesamiento.

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

Considera qué funciones de tu app quieres exponer a la automatización agente. 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 desarrollador agente de extremo a extremo?

Estamos llevando a cabo un Programa de acceso anticipado (EAP) para incorporar apps seleccionadas en la prueba 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 PAA. Si registras tu interés, NO obtendrás 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 las AppFunctions estén disponibles de forma pública.

¿Cómo puedo enviar comentarios sobre AppFunctions?

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