Übersicht über AppFunctions

AppFunctions ist eine Android-Plattform-API mit einer zugehörigen Jetpack-Bibliothek, die die Integration von Android MCP vereinfacht. Ihre Apps können sich damit wie On-Device-MCP-Server verhalten und Funktionen beitragen, die als Tools für die Verwendung durch proaktive Funktionen sowie Agents und Assistenten wie Google Gemini dienen. Seit Mai 2026 ist die AppFunctions-Integration mit Gemini in einer privaten Vorschau mit vertrauenswürdigen Testern verfügbar. Sie können jetzt mit der Vorbereitung Ihrer Apps für die Verwendung von AppFunctions und Entwicklungstools beginnen.

Durch das Definieren dieser AppFunctions kann Ihre App Dienste, Daten und Aktionen für die im Android-Betriebssystem integrierte Registrierung bereitstellen. So können Nutzer Aufgaben über Agents und Interaktionen auf Systemebene erledigen.

AppFunctions sind das mobile Äquivalent von Tools im Model Context Protocol (MCP). Während MCP traditionell standardisiert, wie KI-Agents eine Verbindung zu serverseitigen Tools herstellen, bieten AppFunctions denselben Mechanismus für Android-Apps. So können Sie die Funktionen Ihrer App als orchestrierbare „Tools“ verfügbar machen, die von autorisierten Apps (Aufrufern) erkannt und ausgeführt werden können, um Nutzeranfragen zu erfüllen. Aufrufer müssen die Berechtigung EXECUTE_APP_FUNCTIONS haben, um AppFunctions zu erkennen und auszuführen. Sie können Agents, Apps und KI-Assistenten wie Gemini umfassen.

AppFunctions ist auf Geräten mit Android 16 oder höher verfügbar.

Beispielanwendungsfälle

AppFunctions bieten einen leistungsstarken Mechanismus zum Automatisieren von Aufgaben und Optimieren von Nutzerinteraktionen. Wenn Sie die Funktionen Ihrer App öffnen, können Nutzer komplexe Aufgaben mithilfe von natürlicher Sprache erledigen. Dadurch ist es oft nicht mehr erforderlich, Schritt für Schritt manuell in Ihrer Benutzeroberfläche zu navigieren.

Die folgenden Szenarien veranschaulichen, wie AppFunctions in verschiedenen App-Kategorien eingesetzt werden können:

  • Aufgabenverwaltung und Produktivität

    • Nutzeranfrage: „Erinnere mich daran, heute um 17:00 Uhr mein Paket auf der Arbeit abzuholen.“
    • AppFunction-Aktion: Der Aufrufer identifiziert die relevante App für die Aufgabenverwaltung und ruft eine Funktion auf, um eine Aufgabe zu erstellen. Die Felder für Titel, Uhrzeit und Ort werden automatisch anhand des Prompts des Nutzers ausgefüllt.
    /**
*   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

  • Medien und Unterhaltung

    • Nutzeranfrage: Erstelle eine neue Playlist mit den besten Jazzalben dieses Jahres.
    • AppFunction-Aktion: Der Aufrufer führt eine Funktion zum Erstellen von Playlists in einer Musik-App aus und übergibt Kontext wie „Top-Jazzalben für 2026“ als Anfrage, um die Playlist sofort zu generieren.
    /**
*   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

  • App-übergreifende Workflows

    • Nutzeranfrage: Suche in Lisas E-Mail nach dem Nudelrezept und füge die Zutaten meiner Einkaufsliste hinzu.
    • AppFunction-Aktion: Bei dieser Anfrage werden Funktionen aus mehreren Apps verwendet. Zuerst ruft der Anrufer die Inhalte über die Suchfunktion einer E‑Mail-App ab. Anschließend werden die relevanten Zutaten extrahiert und die Funktion einer Einkaufslisten-App aufgerufen, um die Liste des Nutzers zu füllen.
    /**
*   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

  • Kalender und Terminplanung

    • Nutzeranfrage: Füge meinem Kalender für nächsten Montag um 18:00 Uhr die Geburtstagsparty meiner Mutter hinzu.
    • AppFunction-Aktion: Die genehmigte Agent-App ruft die Funktion „Termin erstellen“ der Kalender-App auf und analysiert den relevanten Kontext wie „nächsten Montag“ und „18:00 Uhr“, um den Eintrag zu erstellen, ohne dass der Nutzer den Kalender manuell öffnen muss.
    /**
*   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

Funktionsweise von AppFunctions

Das folgende Diagramm veranschaulicht den typischen Ablauf, wie AppFunctions von Apps für einen Agent freigegeben und anschließend ausgeführt werden. Agenten berücksichtigen bei der Bearbeitung von Nutzeranfragen wahrscheinlich sowohl serverseitige Remote-MCP-Tools als auch lokale AppFunctions. Der detaillierte Ablauf für die Verwendung lokaler AppFunctions ist wie folgt:

  • AppFunction-Deklaration: Die Android-App ist so konzipiert, dass sie AppFunctions verwendet, um ihre Funktionen wie „Notiz erstellen“ oder „Nachricht senden“ verfügbar zu machen.
  • Schemagenerierung: Die AppFunctions Jetpack-Bibliothek generiert eine XML-Schemadatei, in der alle deklarierten AppFunctions in der App aufgeführt sind. Das Android-Betriebssystem verwendet diese Datei, um die verfügbaren AppFunctions zu indexieren.
  • Metadaten abrufen: Der Agent kann AppFunction-Metadaten abrufen, indem er sie abfragt.
  • Auswahl und Ausführung von AppFunction: Basierend auf Nutzeranfragen wählt der Agent die passende AppFunction mit den entsprechenden Parametern aus und führt sie aus.
Der typische AppFunctions-Ablauf beginnt mit der Präsentation der App und endet mit der Ausführung des Agent.
Abbildung 1: Der typische Ablauf, wie AppFunctions von einem Agenten bereitgestellt und anschließend ausgeführt werden.

Die AppFunctions Jetpack-Bibliothek vereinfacht das Bereitstellen der Funktionen Ihrer App. Mit dem Annotation Processor annotieren Sie die Funktionen, die Sie für Agents verfügbar machen möchten. Anrufer können diese indexierten Funktionen dann mit AppFunctionManager finden und aufrufen.

Bevor sie eine Funktion aufrufen, sollten Aufrufer prüfen, ob das Gerät die Funktion „AppFunctions“ unterstützt, indem sie versuchen, eine Instanz von AppFunctionManager abzurufen. Sobald die Funktion unterstützt wird, können Anrufer mit isAppFunctionEnabled(packageName,functionId) prüfen, ob eine bestimmte Funktion in einer Ziel-App aktiviert ist. Wenn Sie den Status von Funktionen in anderen Paketen abfragen möchten, benötigen Sie die android.permission.EXECUTE_APP_FUNCTIONSpermission.

Ihre App muss nicht prüfen, ob die AppFunction-Funktion unterstützt wird. Das wird automatisch in der Jetpack-Bibliothek erledigt. Mit AppFunctionManager lässt sich beispielsweise prüfen, ob das Feature unterstützt wird.

Hier ist ein Beispiel für AppFunctions für eine Notizen-App mit Funktionen zum Erstellen, Bearbeiten und Auflisten von Notizen:

/**
 * 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
)

Häufig gestellte Fragen

Im folgenden Abschnitt finden Sie Antworten auf häufig gestellte Fragen zu AppFunctions.

Ich bin App-Entwickler. Kann ich AppFunctions heute implementieren?

Ja, es ist möglich, AppFunctions in Ihrer App zu implementieren und zu testen. Folgen Sie dazu der Anleitung in den vorherigen Abschnitten.

Was ist der Unterschied zwischen AppFunctions und MCP?

Mit beiden können KI-Agents Tools orchestrieren, es gibt jedoch erhebliche Unterschiede in Bezug auf Architektur, Latenz und erforderlichen Entwickleraufwand. AppFunctions sind integrierte Hooks auf Betriebssystemebene, die ausschließlich für Android verfügbar sind und lokal ausgeführt werden. Ein Standard-MCP-Server ist dagegen eine plattformunabhängige Lösung, die auf der Ausführung in der Cloud und Netzwerk-Roundtrips basiert.

Kurz gesagt: Wenn Sie AppFunctions verwenden, können Sie den vorhandenen App-Status direkt auf dem Gerät nutzen und müssen keine Dienste außerhalb Ihrer Android-App verwalten.

Ich habe AppFunctions in meiner App implementiert. Warum kann mein System-Agent nicht darauf zugreifen?

AppFunctions sind eine experimentelle Funktion. Um die Qualität des Gesamteindrucks während dieser experimentellen Phase sorgfältig zu bewerten, kann nur eine begrenzte Anzahl von Apps und System-Agents auf die gesamte Pipeline zugreifen.

Wie kann ich meine App auf die allgemeine Verfügbarkeit von AppFunctions vorbereiten?

Überlegen Sie, welche Funktionen Ihrer App Sie für die agentenbasierte Automatisierung verfügbar machen möchten. Sie können AppFunctions in Ihrer App implementieren. Folgen Sie dazu der Anleitung in den vorherigen Abschnitten auf dieser Seite und prüfen Sie, ob sie auf dem Gerät registriert sind, indem Sie adb shell cmd app_function list-app-functions aufrufen.

Kann ich Vorabzugriff auf die End-to-End-Entwicklerfunktionen für agentische KI erhalten?

Wir führen ein Early Access-Programm (EAP) durch, um ausgewählte Apps zu testen und die End-to-End-Entwicklerfunktionen zu testen, die für die Einführung von AppFunctions in der Produktion auf Android erforderlich sind. Wenn Sie Interesse an der Integration Ihrer AppFunctions haben, können Sie sich über dieses Formular für das EAP registrieren. Wenn Sie Ihr Interesse bekunden, erhalten Sie NICHT automatisch Zugriff auf die vollständige Integration. Wir benachrichtigen Sie per E-Mail, wenn Ihre App für das EAP ausgewählt wird oder wenn AppFunctions öffentlich verfügbar werden.

Wie kann ich Feedback zu AppFunctions geben?

Sie können Feedback zur API geben, indem Sie ein Problem melden und Ihr Interesse am Early-Access-Programm im entsprechenden Formular bekunden.